Trait std::cmp::PartialEq1.0.0[−][src]

pub trait PartialEq<Rhs = Self> where
    Rhs: ?Sized, {
    #[must_use]
    fn eq(&self, other: &Rhs) -> bool;

    #[must_use]
    fn ne(&self, other: &Rhs) -> bool { ... }
}

Expand description

等值比较器的 Trait 为部分等价关系。

x.eq(y) 也可以写成 x == y，x.ne(y) 可以写成 x != y。我们在本文档的其余部分使用更易于阅读的中缀符号。

trait 允许部分相等，用于不具有完全等价关系的类型。例如，在浮点数 NaN != NaN 中，因此浮点类型实现 PartialEq，但不实现 Eq。

实现必须确保 eq 和 ne 彼此一致:

a != b 当且仅当 !(a == b) (由默认实现确保)。

如果 Self 和 Rhs 也实现了 PartialOrd 或 Ord，则它们的方法也必须与 PartialEq 一致 (具体要求请参见那些 traits 的文档)。通过派生一些 traits 并手动实现其他一些行为，很容易使它们不以为然。

等式关系 == 必须满足以下条件 (对于所有类型为 A、B、C 的 a、b、c) :

对称: 如果 A: PartialEq 和 B: PartialEq<A>，则 a == b意味着 'b == a; 和
可传递: 如果 A: PartialEq 和 B: PartialEq<C> 以及 A: 偏等式 <C>，然后 a == b，而 b == c 表示a == c。

请注意，B: PartialEq<A> (symmetric) 和 A: PartialEq<C> (transitive) 强制不是强制存在的，但是这些要求只要存在就适用。

Derivable

该 trait 可以与 #[derive] 一起使用。在结构体上 derive d 时，如果所有字段都相等，则两个实例相等; 如果任何字段不相等，则两个实例不相等。对枚举进行派生时，每个成员都等于自己，而不等于另一个成员。

如何实现 `PartialEq`?

一个域的示例实现，在该域中，即使两本书的 ISBN 匹配，即使格式不同，也将其视为同一本书:

enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq for Book {
    fn eq(&self, other: &Self) -> bool {
        self.isbn == other.isbn
    }
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };
let b2 = Book { isbn: 3, format: BookFormat::Ebook };
let b3 = Book { isbn: 10, format: BookFormat::Paperback };

assert!(b1 == b2);
assert!(b1 != b3);

Run

如何比较两种不同的类型?

您可以比较的类型由 PartialEq 的类型参数控制。例如，让我们对之前的代码进行一些调整:

// 衍生工具 <BookFormat> == <BookFormat> 比较
#[derive(PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

struct Book {
    isbn: i32,
    format: BookFormat,
}

// 实现 <Book> == <BookFormat> 比较
impl PartialEq<BookFormat> for Book {
    fn eq(&self, other: &BookFormat) -> bool {
        self.format == *other
    }
}

// 实现 <BookFormat> == <Book> 比较
impl PartialEq<Book> for BookFormat {
    fn eq(&self, other: &Book) -> bool {
        *self == other.format
    }
}

let b1 = Book { isbn: 3, format: BookFormat::Paperback };

assert!(b1 == BookFormat::Paperback);
assert!(BookFormat::Ebook != b1);

Run

通过将 impl PartialEq for Book 更改为 impl PartialEq<BookFormat> for Book，我们可以将 BookFormat 和 Book 进行比较。

像上面这样的比较 (它忽略了结构体的某些字段) 可能很危险。这很容易导致意外违反部分对等关系的要求。例如，如果我们保留了以上针对 BookFormat 的 PartialEq<Book> 的实现，并为 Book 添加了 PartialEq<Book> 的实现 (通过 #[derive] 或第一个示例中的手动实现)，则结果将违反传递性:

#[derive(PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

#[derive(PartialEq)]
struct Book {
    isbn: i32,
    format: BookFormat,
}

impl PartialEq<BookFormat> for Book {
    fn eq(&self, other: &BookFormat) -> bool {
        self.format == *other
    }
}

impl PartialEq<Book> for BookFormat {
    fn eq(&self, other: &Book) -> bool {
        *self == other.format
    }
}

fn main() {
    let b1 = Book { isbn: 1, format: BookFormat::Paperback };
    let b2 = Book { isbn: 2, format: BookFormat::Paperback };

    assert!(b1 == BookFormat::Paperback);
    assert!(BookFormat::Paperback == b2);

    // 以下应该通过传递性来保持，但不是。
    assert!(b1 == b2); // <-- PANICS
}

Run

Examples

let x: u32 = 0;
let y: u32 = 1;

assert_eq!(x == y, false);
assert_eq!(x.eq(&y), false);

Trait std::cmp::PartialEq1.0.0[−][src]

Required methods

#[must_use]fn eq(&self, other: &Rhs) -> bool

Provided methods

#[must_use]fn ne(&self, other: &Rhs) -> bool

Implementations on Foreign Types

impl PartialEq<FromSecsError> for FromSecsError

pub fn eq(&self, other: &FromSecsError) -> bool

pub fn ne(&self, other: &FromSecsError) -> bool

impl PartialEq<CpuidResult> for CpuidResult

pub fn eq(&self, other: &CpuidResult) -> bool

pub fn ne(&self, other: &CpuidResult) -> bool

impl<'a> PartialEq<Utf8LossyChunk<'a>> for Utf8LossyChunk<'a>

pub fn eq(&self, other: &Utf8LossyChunk<'a>) -> bool

pub fn ne(&self, other: &Utf8LossyChunk<'a>) -> bool

Implementors

impl PartialEq<&'_ str> for OsString

fn eq(&self, other: &&str) -> bool

impl PartialEq<BacktraceStatus> for BacktraceStatus

fn eq(&self, other: &BacktraceStatus) -> bool

impl PartialEq<TryReserveError> for TryReserveError

pub fn eq(&self, other: &TryReserveError) -> bool

pub fn ne(&self, other: &TryReserveError) -> bool

impl PartialEq<Infallible> for Infallible

pub fn eq(&self, &Infallible) -> bool

impl PartialEq<VarError> for VarError

fn eq(&self, other: &VarError) -> bool

fn ne(&self, other: &VarError) -> bool

impl PartialEq<ErrorKind> for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

impl PartialEq<SeekFrom> for SeekFrom

fn eq(&self, other: &SeekFrom) -> bool

fn ne(&self, other: &SeekFrom) -> bool

impl PartialEq<IpAddr> for IpAddr

fn eq(&self, other: &IpAddr) -> bool

fn ne(&self, other: &IpAddr) -> bool

impl PartialEq<IpAddr> for Ipv4Addr

fn eq(&self, other: &IpAddr) -> bool

impl PartialEq<IpAddr> for Ipv6Addr

fn eq(&self, other: &IpAddr) -> bool

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

fn eq(&self, other: &Ipv6MulticastScope) -> bool

impl PartialEq<Shutdown> for Shutdown

fn eq(&self, other: &Shutdown) -> bool

impl PartialEq<SocketAddr> for SocketAddr

fn eq(&self, other: &SocketAddr) -> bool

fn ne(&self, other: &SocketAddr) -> bool

impl PartialEq<FpCategory> for FpCategory

pub fn eq(&self, other: &FpCategory) -> bool

impl PartialEq<IntErrorKind> for IntErrorKind

pub fn eq(&self, other: &IntErrorKind) -> bool

impl PartialEq<SearchStep> for SearchStep

pub fn eq(&self, other: &SearchStep) -> bool

pub fn ne(&self, other: &SearchStep) -> bool

impl PartialEq<Ordering> for std::sync::atomic::Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

fn eq(&self, other: &RecvTimeoutError) -> bool

impl PartialEq<TryRecvError> for TryRecvError

fn eq(&self, other: &TryRecvError) -> bool

impl PartialEq<Ordering> for std::cmp::Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<bool> for bool

pub fn eq(&self, other: &bool) -> bool

pub fn ne(&self, other: &bool) -> bool

impl PartialEq<char> for char

pub fn eq(&self, other: &char) -> bool

pub fn ne(&self, other: &char) -> bool

impl PartialEq<f32> for f32

pub fn eq(&self, other: &f32) -> bool

pub fn ne(&self, other: &f32) -> bool

impl PartialEq<f64> for f64

pub fn eq(&self, other: &f64) -> bool

pub fn ne(&self, other: &f64) -> bool

impl PartialEq<i8> for i8

pub fn eq(&self, other: &i8) -> bool

pub fn ne(&self, other: &i8) -> bool

impl PartialEq<i16> for i16

pub fn eq(&self, other: &i16) -> bool

pub fn ne(&self, other: &i16) -> bool

#[must_use]
fn eq(&self, other: &Rhs) -> bool

#[must_use]
fn ne(&self, other: &Rhs) -> bool