Trait otter_api_tests::cmp::PartialEq

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

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

Trait for equality comparisons which are partial equivalence relations.

This trait allows for partial equality, for types that do not have a full equivalence relation. For example, in floating point numbers NaN != NaN, so floating point types implement PartialEq but not Eq.

Formally, the equality must be (for all a, b, c of type A, B, C):

• Symmetric: if A: PartialEq<B> and B: PartialEq<A>, then a == b implies b == a; and

• Transitive: if A: PartialEq<B> and B: PartialEq<C> and A: PartialEq<C>, then a == b and b == c implies a == c.

Note that the B: PartialEq<A> (symmetric) and A: PartialEq<C> (transitive) impls are not forced to exist, but these requirements apply whenever they do exist.

Derivable

This trait can be used with #[derive]. When derived on structs, two instances are equal if all fields are equal, and not equal if any fields are not equal. When derived on enums, each variant is equal to itself and not equal to the other variants.

How can I implement PartialEq?

PartialEq only requires the eq method to be implemented; ne is defined in terms of it by default. Any manual implementation of ne must respect the rule that eq is a strict inverse of ne; that is, !(a == b) if and only if a != b.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. It’s easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

An example implementation for a domain in which two books are considered the same book if their ISBN matches, even if the formats differ:

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);

How can I compare two different types?

The type you can compare with is controlled by PartialEq’s type parameter. For example, let’s tweak our previous code a bit:

// The derive implements <BookFormat> == <BookFormat> comparisons
#[derive(PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

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

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

// Implement <BookFormat> == <Book> comparisons
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);

By changing impl PartialEq for Book to impl PartialEq<BookFormat> for Book, we allow BookFormats to be compared with Books.

A comparison like the one above, which ignores some fields of the struct, can be dangerous. It can easily lead to an unintended violation of the requirements for a partial equivalence relation. For example, if we kept the above implementation of PartialEq<Book> for BookFormat and added an implementation of PartialEq<Book> for Book (either via a #[derive] or via the manual implementation from the first example) then the result would violate transitivity:

#[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);

    // The following should hold by transitivity but doesn't.
    assert!(b1 == b2); // <-- PANICS
}

Examples

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

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

Required methods

#[must_use]

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

This method tests for self and other values to be equal, and is used by ==.

Loading content...

Provided methods

#[must_use]

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

This method tests for !=.

Loading content...

Implementations on Foreign Types

impl PartialEq<Ipv6Addr> for Ipv6Addr

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

impl PartialEq<OsStr> for str

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

impl PartialEq<CStr> for CStr

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

impl<'a, 'b> PartialEq<OsString> for &'a Path

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

impl PartialEq<StripPrefixError> for StripPrefixError

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

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

impl<'a, 'b> PartialEq<PathBuf> for OsString

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

impl<T> PartialEq<SyncOnceCell<T>> for SyncOnceCell<T> where
    T: PartialEq<T>, 

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

impl PartialEq<Shutdown> for Shutdown

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

impl PartialEq<CString> for CString

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

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

impl<'a, 'b> PartialEq<OsStr> for &'a Path

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

impl PartialEq<FromBytesWithNulError> for FromBytesWithNulError

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

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

impl PartialEq<Output> for Output

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

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

impl<'a, 'b> PartialEq<Cow<'b, OsStr>> for &'a Path

pub fn eq(&self, other: &Cow<'b, OsStr>) -> bool

impl PartialEq<NulError> for NulError

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

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

impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsString

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

impl<'a, 'b> PartialEq<Path> for OsString

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

impl PartialEq<Path> for Path

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

impl PartialEq<OsString> for str

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

impl<'a> PartialEq<Components<'a>> for Components<'a>

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

impl PartialEq<SocketAddrV6> for SocketAddrV6

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

impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b Path

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

impl PartialEq<IpAddr> for Ipv6Addr

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

impl PartialEq<AddrParseError> for AddrParseError

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

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

impl PartialEq<Ipv4Addr> for IpAddr

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

impl PartialEq<OsString> for OsString

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

impl<'a, 'b> PartialEq<&'a OsStr> for OsString

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

impl<'_> PartialEq<&'_ str> for OsString

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

impl PartialEq<IntoStringError> for IntoStringError

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

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

impl<'a, 'b> PartialEq<PathBuf> for &'a Path

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

impl PartialEq<WaitTimeoutResult> for WaitTimeoutResult

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

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

impl<'a, 'b> PartialEq<Cow<'a, Path>> for Path

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

impl<'a> PartialEq<Prefix<'a>> for Prefix<'a>

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

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

impl<'a, 'b> PartialEq<OsStr> for OsString

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

impl<'a, 'b> PartialEq<&'a Path> for OsString

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

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for Path

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

impl PartialEq<Ipv6MulticastScope> for Ipv6MulticastScope

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

impl PartialEq<Ipv4Addr> for Ipv4Addr

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

impl<'a> PartialEq<Component<'a>> for Component<'a>

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

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

impl PartialEq<IpAddr> for Ipv4Addr

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

impl<'a, 'b> PartialEq<&'a OsStr> for Path

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

impl PartialEq<SocketAddrV4> for SocketAddrV4

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

impl PartialEq<BacktraceStatus> for BacktraceStatus

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

impl<'a, 'b> PartialEq<OsStr> for Path

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

impl<'a> PartialEq<PrefixComponent<'a>> for PrefixComponent<'a>

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

impl PartialEq<Ipv6Addr> for IpAddr

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

impl<'a, 'b> PartialEq<PathBuf> for Path

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

impl PartialEq<str> for OsString

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

impl PartialEq<FromVecWithNulError> for FromVecWithNulError

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

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

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsString

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

impl<'a> PartialEq<OsString> for &'a str

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

impl PartialEq<IpAddr> for IpAddr

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

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

impl PartialEq<ExitStatus> for ExitStatus

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

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

impl<'a, 'b> PartialEq<OsString> for Path

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

impl PartialEq<SocketAddr> for SocketAddr

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

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool

impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool

impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool

impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool

impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret

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

impl PartialEq<i32> for i32

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool

impl PartialEq<u8> for u8

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool

impl<A, B, C, D> PartialEq<(A, B, C, D)> for (A, B, C, D) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    A: PartialEq<A>,
    D: PartialEq<D> + ?Sized, 

pub fn eq(&self, other: &(A, B, C, D)) -> bool

pub fn ne(&self, other: &(A, B, C, D)) -> bool

impl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool

impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

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

impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B]> for [A; N] where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&mut [B]) -> bool

pub fn ne(&self, other: &&mut [B]) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> bool

impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret

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

impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

pub fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool

impl PartialEq<i16> for i16

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

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

impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool

impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool

impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool

impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool

impl PartialEq<()> for ()

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

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

impl<Ret, A, B, C, D, E, F, G> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> bool

impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool

impl PartialEq<!> for !

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

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> bool

impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool

impl PartialEq<i128> for i128

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

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

impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool

impl<T> PartialEq<*const T> for *const T where
    T: ?Sized, 

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool

impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool

impl<'_, A, B, const N: usize> PartialEq<&'_ [B]> for [A; N] where
    A: PartialEq<B>, 

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

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

impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool

impl PartialEq<u16> for u16

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool

impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N] where
    A: PartialEq<B>, 

pub fn eq(&self, other: &[B; N]) -> bool

pub fn ne(&self, other: &[B; N]) -> bool

impl<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    D: PartialEq<D>,
    H: PartialEq<H> + ?Sized, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ mut A where
    B: ?Sized,
    A: PartialEq<B> + ?Sized, 

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<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

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

impl PartialEq<f64> for f64

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(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
    C: PartialEq<C>,
    L: PartialEq<L> + ?Sized,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    K: PartialEq<K>,
    I: PartialEq<I>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    D: PartialEq<D>,
    H: PartialEq<H>,
    J: PartialEq<J>, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

impl<A, B, C> PartialEq<(A, B, C)> for (A, B, C) where
    C: PartialEq<C> + ?Sized,
    B: PartialEq<B>,
    A: PartialEq<A>, 

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

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

impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F> PartialEq<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<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

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool

impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool

impl<'_, A, B, const N: usize> PartialEq<[A; N]> for &'_ mut [B] where
    B: PartialEq<A>, 

pub fn eq(&self, other: &[A; N]) -> bool

pub fn ne(&self, other: &[A; N]) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool

impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    F: PartialEq<F> + ?Sized,
    D: PartialEq<D>, 

pub fn eq(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F)) -> bool

impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool

impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ A where
    B: ?Sized,
    A: PartialEq<B> + ?Sized, 

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

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

impl<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    F: PartialEq<F>,
    G: PartialEq<G> + ?Sized,
    D: PartialEq<D>, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G)) -> bool

impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool

impl PartialEq<char> for char

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

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

impl PartialEq<isize> for isize

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

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

impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool

impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

pub fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool

impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool

impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret

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

impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for (A, B, C, D, E) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E> + ?Sized,
    A: PartialEq<A>,
    D: PartialEq<D>, 

pub fn eq(&self, other: &(A, B, C, D, E)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E)) -> bool

impl PartialEq<u32> for u32

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

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

impl PartialEq<u128> for u128

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

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

impl<A> PartialEq<(A,)> for (A,) where
    A: PartialEq<A> + ?Sized, 

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

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

impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret

pub fn eq(&self, other: &extern "C" fn() -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool

impl<'_, A, B, const N: usize> PartialEq<[A; N]> for &'_ [B] where
    B: PartialEq<A>, 

pub fn eq(&self, other: &[A; N]) -> bool

pub fn ne(&self, other: &[A; N]) -> bool

impl<A, B> PartialEq<(A, B)> for (A, B) where
    B: PartialEq<B> + ?Sized,
    A: PartialEq<A>, 

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

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

impl PartialEq<usize> for usize

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

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

impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool

impl<A, B, const N: usize> PartialEq<[A; N]> for [B] where
    B: PartialEq<A>, 

pub fn eq(&self, other: &[A; N]) -> bool

pub fn ne(&self, other: &[A; N]) -> bool

impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

pub fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool

impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool

impl<T> PartialEq<*mut T> for *mut T where
    T: ?Sized, 

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

impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ A where
    B: ?Sized,
    A: PartialEq<B> + ?Sized, 

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

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

impl<A, B, const N: usize> PartialEq<[B]> for [A; N] where
    A: PartialEq<B>, 

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

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

impl PartialEq<f32> for f32

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    K: PartialEq<K> + ?Sized,
    I: PartialEq<I>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    D: PartialEq<D>,
    H: PartialEq<H>,
    J: PartialEq<J>, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<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

pub fn eq(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool

impl PartialEq<bool> for bool

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

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

impl PartialEq<u64> for u64

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

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

impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool

impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret

pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool

impl PartialEq<str> for str

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

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

impl<Ret, A, B, C, D, E, F, G, H> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool

impl<A, B> PartialEq<[B]> for [A] where
    A: PartialEq<B>, 

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

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

impl PartialEq<i64> for i64

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

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

impl<A, B, C, D, E, F, G, H, I, J> PartialEq<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    I: PartialEq<I>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    D: PartialEq<D>,
    H: PartialEq<H>,
    J: PartialEq<J> + ?Sized, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

impl PartialEq<i8> for i8

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

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

impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool

impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
    B: ?Sized,
    A: PartialEq<B> + ?Sized, 

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

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

impl<A, B, C, D, E, F, G, H, I> PartialEq<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
    C: PartialEq<C>,
    B: PartialEq<B>,
    E: PartialEq<E>,
    A: PartialEq<A>,
    I: PartialEq<I> + ?Sized,
    F: PartialEq<F>,
    G: PartialEq<G>,
    D: PartialEq<D>,
    H: PartialEq<H>, 

pub fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

pub fn ne(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<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

pub fn eq(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool

impl<'_, T, U, A> PartialEq<&'_ [U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

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

impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ [T] where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl<'a, 'b> PartialEq<String> for str

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

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

impl PartialEq<String> for String

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

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

impl<'_, T, U, A> PartialEq<Vec<U, A>> for &'_ mut [T] where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl<T> PartialEq<Rc<T>> for Rc<T> where
    T: PartialEq<T> + ?Sized, 

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

Equality for two Rcs.

Two Rcs are equal if their inner values are equal, even if they are stored in different allocation.

If T also implements Eq (implying reflexivity of equality), two Rcs that point to the same allocation are always equal.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five == Rc::new(5));

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

Inequality for two Rcs.

Two Rcs are unequal if their inner values are unequal.

If T also implements Eq (implying reflexivity of equality), two Rcs that point to the same allocation are never unequal.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five != Rc::new(6));

impl<'a, 'b> PartialEq<Cow<'a, str>> for String

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

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

impl<'a, 'b> PartialEq<&'a str> for String

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

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

impl PartialEq<TryReserveError> for TryReserveError

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

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

impl<T, U, A> PartialEq<Vec<U, A>> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl PartialEq<FromUtf8Error> for FromUtf8Error

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

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

impl<'a, 'b> PartialEq<String> for &'a str

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

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

impl<'a, 'b> PartialEq<str> for String

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

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

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

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

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

impl<T, U, A> PartialEq<[U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

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

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

impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
    T: PartialEq<T>, 

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

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

impl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &[U; N]) -> bool

pub fn ne(&self, other: &[U; N]) -> bool

impl<T, U, A> PartialEq<Vec<U, A>> for [T] where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl<'_, T, U, A> PartialEq<&'_ mut [U]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &&mut [U]) -> bool

pub fn ne(&self, other: &&mut [U]) -> bool

impl<'a, 'b> PartialEq<Cow<'a, str>> for str

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

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

impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
    T: PartialEq<U>,
    A: Allocator, 

pub fn eq(&self, other: &&[U; N]) -> bool

pub fn ne(&self, other: &&[U; N]) -> bool

impl<T, A> PartialEq<Box<T, A>> for Box<T, A> where
    T: PartialEq<T> + ?Sized,
    A: Allocator, 

pub fn eq(&self, other: &Box<T, A>) -> bool

pub fn ne(&self, other: &Box<T, A>) -> bool

impl PartialEq<_Unwind_Action> for _Unwind_Action

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

impl PartialEq<_Unwind_Reason_Code> for _Unwind_Reason_Code

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

impl PartialEq<Notch> for usize

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

impl PartialEq<DescId> for usize

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

impl PartialEq<FaceId> for usize

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

impl PartialEq<SvgId> for usize

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

impl PartialEq<InHand> for usize

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

impl<A> PartialEq<ArrayString<A>> for str where
    A: Array<Item = u8> + Copy, 

pub fn eq(&self, rhs: &ArrayString<A>) -> bool

impl PartialEq<Value> for bool

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

impl PartialEq<Value> for u64

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

impl PartialEq<Value> for isize

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

impl PartialEq<Value> for f64

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

impl PartialEq<Value> for i16

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

impl PartialEq<Value> for String

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

impl<'a> PartialEq<Value> for &'a str

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

impl PartialEq<Value> for i32

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

impl PartialEq<Value> for i8

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

impl PartialEq<Value> for u16

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

impl PartialEq<Value> for usize

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

impl PartialEq<Value> for i64

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

impl PartialEq<Value> for str

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

impl PartialEq<Value> for u8

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

impl PartialEq<Value> for u32

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

impl PartialEq<Value> for f32

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

impl<Sep, T> PartialEq<StringWithSeparator<Sep, T>> for StringWithSeparator<Sep, T> where
    T: PartialEq<T>,
    Sep: PartialEq<Sep>, 

pub fn eq(&self, other: &StringWithSeparator<Sep, T>) -> bool

pub fn ne(&self, other: &StringWithSeparator<Sep, T>) -> bool

impl PartialEq<SpaceSeparator> for SpaceSeparator

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

impl PartialEq<CommaSeparator> for CommaSeparator

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

impl PartialEq<Timespec> for Timespec

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

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

impl PartialEq<ParseError> for ParseError

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

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

impl PartialEq<SteadyTime> for SteadyTime

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

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

impl PartialEq<OutOfRangeError> for OutOfRangeError

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

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

impl PartialEq<Tm> for Tm

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

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

impl<A> PartialEq<ExtendedGcd<A>> for ExtendedGcd<A> where
    A: PartialEq<A>, 

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

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

impl PartialEq<Char> for char

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

impl PartialEq<MatchKind> for MatchKind

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

impl PartialEq<Match> for Match

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

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

impl PartialEq<MatchKind> for MatchKind

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

impl PartialEq<RepetitionKind> for RepetitionKind

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

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

impl PartialEq<ClassUnicodeRange> for ClassUnicodeRange

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

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

impl PartialEq<ClassBytesRange> for ClassBytesRange

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<Literals> for Literals

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

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

impl PartialEq<Position> for Position

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

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

impl PartialEq<Flags> for Flags

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

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

impl PartialEq<CaptureName> for CaptureName

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

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

impl PartialEq<Concat> for Concat

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

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

impl PartialEq<Utf8Range> for Utf8Range

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

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

impl PartialEq<RepetitionRange> for RepetitionRange

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

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

impl PartialEq<ClassSetBinaryOp> for ClassSetBinaryOp

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

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

impl PartialEq<ClassPerlKind> for ClassPerlKind

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

impl PartialEq<Assertion> for Assertion

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

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

impl PartialEq<Hir> for Hir

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<HirKind> for HirKind

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<ClassBracketed> for ClassBracketed

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

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

impl PartialEq<ClassSetUnion> for ClassSetUnion

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

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

impl PartialEq<Alternation> for Alternation

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

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

impl PartialEq<FlagsItem> for FlagsItem

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

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

impl PartialEq<WordBoundary> for WordBoundary

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

impl PartialEq<Class> for Class

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

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

impl PartialEq<Class> for Class

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

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

impl PartialEq<Comment> for Comment

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

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

impl PartialEq<AssertionKind> for AssertionKind

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

impl PartialEq<ClassSetItem> for ClassSetItem

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

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

impl PartialEq<RepetitionOp> for RepetitionOp

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

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

impl PartialEq<Ast> for Ast

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

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

impl PartialEq<ClassUnicodeKind> for ClassUnicodeKind

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

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

impl PartialEq<ClassAsciiKind> for ClassAsciiKind

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

impl PartialEq<ClassPerl> for ClassPerl

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

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

impl PartialEq<Span> for Span

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

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

impl PartialEq<RepetitionRange> for RepetitionRange

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

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

impl PartialEq<ClassUnicode> for ClassUnicode

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

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

impl PartialEq<ClassSetRange> for ClassSetRange

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

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

impl PartialEq<Literal> for Literal

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

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

impl PartialEq<Group> for Group

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

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

impl PartialEq<Anchor> for Anchor

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

impl PartialEq<GroupKind> for GroupKind

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

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

impl PartialEq<ClassSet> for ClassSet

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

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

impl PartialEq<Repetition> for Repetition

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

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

impl PartialEq<ClassSetBinaryOpKind> for ClassSetBinaryOpKind

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

impl PartialEq<Group> for Group

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

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

impl PartialEq<Literal> for Literal

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

impl PartialEq<ErrorKind> for ErrorKind

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

impl PartialEq<WithComments> for WithComments

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

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

impl PartialEq<Literal> for Literal

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

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

impl PartialEq<ClassUnicodeOpKind> for ClassUnicodeOpKind

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

impl PartialEq<RepetitionKind> for RepetitionKind

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

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

impl PartialEq<ErrorKind> for ErrorKind

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

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

impl PartialEq<GroupKind> for GroupKind

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

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

impl PartialEq<HexLiteralKind> for HexLiteralKind

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

impl PartialEq<ClassAscii> for ClassAscii

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

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

impl PartialEq<FlagsItemKind> for FlagsItemKind

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

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

impl PartialEq<Repetition> for Repetition

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

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

impl PartialEq<LiteralKind> for LiteralKind

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

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

impl PartialEq<SpecialLiteralKind> for SpecialLiteralKind

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

impl PartialEq<ClassUnicode> for ClassUnicode

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

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

impl PartialEq<SetFlags> for SetFlags

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

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

impl PartialEq<Flag> for Flag

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

impl PartialEq<ClassBytes> for ClassBytes

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

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

impl PartialEq<Utf8Sequence> for Utf8Sequence

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

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

impl PartialEq<Timestamp> for Timestamp

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

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

impl PartialEq<Duration> for Duration

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

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<Error> for Error

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

impl PartialEq<ColorChoice> for ColorChoice

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

impl PartialEq<Color> for Color

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

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

impl PartialEq<ColorSpec> for ColorSpec

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

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

impl PartialEq<ParseColorError> for ParseColorError

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

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

impl PartialEq<PrintFmt> for PrintFmt

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

impl PartialEq<DwVirtuality> for DwVirtuality

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

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

impl<R> PartialEq<UnwindTableRow<R>> for UnwindTableRow<R> where
    R: PartialEq<R> + Reader, 

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

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

impl PartialEq<LineEncoding> for LineEncoding

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

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

impl<R> PartialEq<Expression<R>> for Expression<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<T> PartialEq<DebugRngListsBase<T>> for DebugRngListsBase<T> where
    T: PartialEq<T>, 

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

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

impl<T> PartialEq<DebugInfoOffset<T>> for DebugInfoOffset<T> where
    T: PartialEq<T>, 

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

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

impl<R> PartialEq<LocationListEntry<R>> for LocationListEntry<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<R> PartialEq<EhFrame<R>> for EhFrame<R> where
    R: PartialEq<R> + Reader, 

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

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

impl PartialEq<LineRow> for LineRow

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

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

impl<R, Offset> PartialEq<Piece<R, Offset>> for Piece<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &Piece<R, Offset>) -> bool

pub fn ne(&self, other: &Piece<R, Offset>) -> bool

impl PartialEq<Range> for Range

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

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

impl PartialEq<DwAt> for DwAt

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

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

impl<R> PartialEq<CallFrameInstruction<R>> for CallFrameInstruction<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<T> PartialEq<DebugMacroOffset<T>> for DebugMacroOffset<T> where
    T: PartialEq<T>, 

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

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

impl<Offset> PartialEq<UnitType<Offset>> for UnitType<Offset> where
    Offset: PartialEq<Offset> + ReaderOffset, 

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

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

impl PartialEq<DwLne> for DwLne

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

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

impl PartialEq<ValueType> for ValueType

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

impl PartialEq<DwEnd> for DwEnd

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

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

impl<'bases, Section, R> PartialEq<PartialFrameDescriptionEntry<'bases, Section, R>> for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: PartialEq<R> + Reader,
    Section: PartialEq<Section> + UnwindSection<R>,
    <R as Reader>::Offset: PartialEq<<R as Reader>::Offset>,
    <Section as UnwindSection<R>>::Offset: PartialEq<<Section as UnwindSection<R>>::Offset>, 

pub fn eq(
    &self,
    other: &PartialFrameDescriptionEntry<'bases, Section, R>
) -> bool

pub fn ne(
    &self,
    other: &PartialFrameDescriptionEntry<'bases, Section, R>
) -> bool

impl PartialEq<ColumnType> for ColumnType

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

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

impl PartialEq<Augmentation> for Augmentation

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

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

impl PartialEq<Abbreviation> for Abbreviation

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

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

impl PartialEq<SectionId> for SectionId

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

impl PartialEq<Encoding> for Encoding

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

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

impl PartialEq<Register> for Register

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

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

impl PartialEq<Error> for Error

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

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

impl<T> PartialEq<DebugLineOffset<T>> for DebugLineOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwLnct> for DwLnct

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

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

impl<T> PartialEq<DebugRngListsIndex<T>> for DebugRngListsIndex<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwLle> for DwLle

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

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

impl<T> PartialEq<ArangeEntry<T>> for ArangeEntry<T> where
    T: PartialEq<T> + Copy, 

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

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

impl PartialEq<DwTag> for DwTag

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

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

impl<T> PartialEq<DebugMacinfoOffset<T>> for DebugMacinfoOffset<T> where
    T: PartialEq<T>, 

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

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

impl<T> PartialEq<DebugLineStrOffset<T>> for DebugLineStrOffset<T> where
    T: PartialEq<T>, 

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

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

impl<R, Offset> PartialEq<FileEntry<R, Offset>> for FileEntry<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &FileEntry<R, Offset>) -> bool

pub fn ne(&self, other: &FileEntry<R, Offset>) -> bool

impl PartialEq<DwMacro> for DwMacro

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

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

impl PartialEq<DwId> for DwId

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

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

impl<R, Offset> PartialEq<LineProgramHeader<R, Offset>> for LineProgramHeader<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &LineProgramHeader<R, Offset>) -> bool

pub fn ne(&self, other: &LineProgramHeader<R, Offset>) -> bool

impl<T> PartialEq<DieReference<T>> for DieReference<T> where
    T: PartialEq<T>, 

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

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

impl<R> PartialEq<Attribute<R>> for Attribute<R> where
    R: PartialEq<R> + Reader, 

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

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

impl PartialEq<DwCfa> for DwCfa

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

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

impl PartialEq<DwLns> for DwLns

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

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

impl PartialEq<DwDs> for DwDs

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

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

impl<T> PartialEq<DebugStrOffsetsBase<T>> for DebugStrOffsetsBase<T> where
    T: PartialEq<T>, 

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

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

impl<R> PartialEq<UnwindContext<R>> for UnwindContext<R> where
    R: Reader + PartialEq<R>, 

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

impl PartialEq<DwUt> for DwUt

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

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

impl PartialEq<Value> for Value

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

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

impl<T> PartialEq<DebugTypesOffset<T>> for DebugTypesOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<Pointer> for Pointer

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

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

impl PartialEq<DwCc> for DwCc

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

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

impl PartialEq<DwRle> for DwRle

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

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

impl PartialEq<DwIdx> for DwIdx

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

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

impl PartialEq<Format> for Format

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

impl PartialEq<DwVis> for DwVis

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

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

impl<T> PartialEq<DebugLocListsIndex<T>> for DebugLocListsIndex<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwoId> for DwoId

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

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

impl<R> PartialEq<CfaRule<R>> for CfaRule<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<T> PartialEq<UnitOffset<T>> for UnitOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwForm> for DwForm

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

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

impl PartialEq<SectionBaseAddresses> for SectionBaseAddresses

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

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

impl PartialEq<DwAddr> for DwAddr

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

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

impl PartialEq<BigEndian> for BigEndian

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

impl<R, Offset> PartialEq<IncompleteLineProgram<R, Offset>> for IncompleteLineProgram<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &IncompleteLineProgram<R, Offset>) -> bool

pub fn ne(&self, other: &IncompleteLineProgram<R, Offset>) -> bool

impl PartialEq<DwLang> for DwLang

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

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

impl<'input, Endian> PartialEq<EndianSlice<'input, Endian>> for EndianSlice<'input, Endian> where
    Endian: PartialEq<Endian> + Endianity, 

pub fn eq(&self, other: &EndianSlice<'input, Endian>) -> bool

pub fn ne(&self, other: &EndianSlice<'input, Endian>) -> bool

impl<T> PartialEq<LocationListsOffset<T>> for LocationListsOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<BaseAddresses> for BaseAddresses

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

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

impl PartialEq<DwarfFileType> for DwarfFileType

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

impl PartialEq<DwInl> for DwInl

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

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

impl PartialEq<DwEhPe> for DwEhPe

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

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

impl<T> PartialEq<DebugAddrIndex<T>> for DebugAddrIndex<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<RunTimeEndian> for RunTimeEndian

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

impl<T> PartialEq<DebugStrOffsetsIndex<T>> for DebugStrOffsetsIndex<T> where
    T: PartialEq<T>, 

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

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

impl<R, Offset> PartialEq<Operation<R, Offset>> for Operation<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &Operation<R, Offset>) -> bool

pub fn ne(&self, other: &Operation<R, Offset>) -> bool

impl<R, Offset> PartialEq<CompleteLineProgram<R, Offset>> for CompleteLineProgram<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &CompleteLineProgram<R, Offset>) -> bool

pub fn ne(&self, other: &CompleteLineProgram<R, Offset>) -> bool

impl<T> PartialEq<DebugAbbrevOffset<T>> for DebugAbbrevOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwAccess> for DwAccess

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

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

impl<R> PartialEq<EvaluationResult<R>> for EvaluationResult<R> where
    R: PartialEq<R> + Reader,
    <R as Reader>::Offset: PartialEq<<R as Reader>::Offset>, 

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

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

impl PartialEq<DwOp> for DwOp

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

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

impl<R, Offset> PartialEq<UnitHeader<R, Offset>> for UnitHeader<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &UnitHeader<R, Offset>) -> bool

pub fn ne(&self, other: &UnitHeader<R, Offset>) -> bool

impl<T> PartialEq<DebugStrOffset<T>> for DebugStrOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<AttributeSpecification> for AttributeSpecification

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

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

impl PartialEq<ReaderOffsetId> for ReaderOffsetId

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

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

impl PartialEq<DwDsc> for DwDsc

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

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

impl<R, Offset> PartialEq<AttributeValue<R, Offset>> for AttributeValue<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &AttributeValue<R, Offset>) -> bool

pub fn ne(&self, other: &AttributeValue<R, Offset>) -> bool

impl PartialEq<DwChildren> for DwChildren

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

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

impl PartialEq<DwOrd> for DwOrd

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

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

impl<T> PartialEq<EhFrameOffset<T>> for EhFrameOffset<T> where
    T: PartialEq<T>, 

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

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

impl<R> PartialEq<DebugFrame<R>> for DebugFrame<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<T> PartialEq<RangeListsOffset<T>> for RangeListsOffset<T> where
    T: PartialEq<T>, 

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

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

impl<T> PartialEq<DebugAddrBase<T>> for DebugAddrBase<T> where
    T: PartialEq<T>, 

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

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

impl<R, Offset> PartialEq<LineInstruction<R, Offset>> for LineInstruction<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &LineInstruction<R, Offset>) -> bool

pub fn ne(&self, other: &LineInstruction<R, Offset>) -> bool

impl PartialEq<DwDefaulted> for DwDefaulted

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

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

impl PartialEq<LittleEndian> for LittleEndian

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

impl<R, Offset> PartialEq<FrameDescriptionEntry<R, Offset>> for FrameDescriptionEntry<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &FrameDescriptionEntry<R, Offset>) -> bool

pub fn ne(&self, other: &FrameDescriptionEntry<R, Offset>) -> bool

impl<R, Offset> PartialEq<Location<R, Offset>> for Location<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &Location<R, Offset>) -> bool

pub fn ne(&self, other: &Location<R, Offset>) -> bool

impl<T> PartialEq<UnitSectionOffset<T>> for UnitSectionOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DwAte> for DwAte

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

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

impl PartialEq<FileEntryFormat> for FileEntryFormat

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

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

impl<R, Offset> PartialEq<CommonInformationEntry<R, Offset>> for CommonInformationEntry<R, Offset> where
    R: PartialEq<R> + Reader<Offset = Offset>,
    Offset: PartialEq<Offset> + ReaderOffset, 

pub fn eq(&self, other: &CommonInformationEntry<R, Offset>) -> bool

pub fn ne(&self, other: &CommonInformationEntry<R, Offset>) -> bool

impl<T> PartialEq<DebugLocListsBase<T>> for DebugLocListsBase<T> where
    T: PartialEq<T>, 

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

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

impl<R> PartialEq<EhFrameHdr<R>> for EhFrameHdr<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<T> PartialEq<DebugFrameOffset<T>> for DebugFrameOffset<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DebugTypeSignature> for DebugTypeSignature

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

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

impl<R> PartialEq<RegisterRule<R>> for RegisterRule<R> where
    R: PartialEq<R> + Reader, 

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

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

impl<'bases, Section, R> PartialEq<CieOrFde<'bases, Section, R>> for CieOrFde<'bases, Section, R> where
    R: PartialEq<R> + Reader,
    Section: PartialEq<Section> + UnwindSection<R>, 

pub fn eq(&self, other: &CieOrFde<'bases, Section, R>) -> bool

pub fn ne(&self, other: &CieOrFde<'bases, Section, R>) -> bool

impl PartialEq<SectionIndex> for SectionIndex

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

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

impl PartialEq<FileFlags> for FileFlags

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

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

impl PartialEq<SymbolIndex> for SymbolIndex

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

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

impl PartialEq<SectionKind> for SectionKind

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

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

impl<E> PartialEq<I16Bytes<E>> for I16Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl PartialEq<RelocationTarget> for RelocationTarget

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

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

impl PartialEq<Error> for Error

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

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

impl<'data> PartialEq<CompressedData<'data>> for CompressedData<'data>

pub fn eq(&self, other: &CompressedData<'data>) -> bool

pub fn ne(&self, other: &CompressedData<'data>) -> bool

impl PartialEq<AddressSize> for AddressSize

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

impl<E> PartialEq<U64Bytes<E>> for U64Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl<'data> PartialEq<SymbolMapName<'data>> for SymbolMapName<'data>

pub fn eq(&self, other: &SymbolMapName<'data>) -> bool

pub fn ne(&self, other: &SymbolMapName<'data>) -> bool

impl PartialEq<SectionFlags> for SectionFlags

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

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

impl PartialEq<SymbolScope> for SymbolScope

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

impl<'data> PartialEq<Import<'data>> for Import<'data>

pub fn eq(&self, other: &Import<'data>) -> bool

pub fn ne(&self, other: &Import<'data>) -> bool

impl PartialEq<SymbolSection> for SymbolSection

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

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

impl PartialEq<RelocationEncoding> for RelocationEncoding

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

impl PartialEq<CompressionFormat> for CompressionFormat

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

impl<E> PartialEq<U16Bytes<E>> for U16Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl<'data> PartialEq<ObjectMapEntry<'data>> for ObjectMapEntry<'data>

pub fn eq(&self, other: &ObjectMapEntry<'data>) -> bool

pub fn ne(&self, other: &ObjectMapEntry<'data>) -> bool

impl PartialEq<Architecture> for Architecture

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

impl PartialEq<BinaryFormat> for BinaryFormat

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

impl PartialEq<RelocationKind> for RelocationKind

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

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

impl PartialEq<SymbolKind> for SymbolKind

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

impl<E> PartialEq<I32Bytes<E>> for I32Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl PartialEq<ArchiveKind> for ArchiveKind

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

impl PartialEq<Endianness> for Endianness

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

impl<Section> PartialEq<SymbolFlags<Section>> for SymbolFlags<Section> where
    Section: PartialEq<Section>, 

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

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

impl<'data> PartialEq<Bytes<'data>> for Bytes<'data>

pub fn eq(&self, other: &Bytes<'data>) -> bool

pub fn ne(&self, other: &Bytes<'data>) -> bool

impl<E> PartialEq<I64Bytes<E>> for I64Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl PartialEq<BigEndian> for BigEndian

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

impl<E> PartialEq<U32Bytes<E>> for U32Bytes<E> where
    E: PartialEq<E> + Endian, 

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

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

impl<'data> PartialEq<Export<'data>> for Export<'data>

pub fn eq(&self, other: &Export<'data>) -> bool

pub fn ne(&self, other: &Export<'data>) -> bool

impl PartialEq<LittleEndian> for LittleEndian

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

impl PartialEq<ComdatKind> for ComdatKind

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

impl PartialEq<MZFlush> for MZFlush

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

impl PartialEq<TDEFLFlush> for TDEFLFlush

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

impl PartialEq<MZError> for MZError

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

impl PartialEq<CompressionLevel> for CompressionLevel

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

impl PartialEq<DataFormat> for DataFormat

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

impl PartialEq<TDEFLStatus> for TDEFLStatus

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

impl PartialEq<MZStatus> for MZStatus

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

impl PartialEq<TINFLStatus> for TINFLStatus

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

impl PartialEq<StreamResult> for StreamResult

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

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

impl PartialEq<CompressionStrategy> for CompressionStrategy

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

impl PartialEq<Color> for Color

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

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

impl PartialEq<Style> for Style

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

impl<T> PartialEq<Paint<T>> for Paint<T> where
    T: PartialEq<T>, 

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

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

impl PartialEq<DebouncedEvent> for DebouncedEvent

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

impl PartialEq<Op> for Op

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

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

impl PartialEq<RecursiveMode> for RecursiveMode

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

impl PartialEq<FileTime> for FileTime

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

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

impl PartialEq<PollOpt> for PollOpt

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

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

impl PartialEq<Token> for Token

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

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

impl PartialEq<UnixReady> for UnixReady

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

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

impl PartialEq<Event> for Event

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

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

impl PartialEq<Ready> for Ready

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

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

impl PartialEq<WatchMask> for WatchMask

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

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

impl PartialEq<EventMask> for EventMask

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

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

impl PartialEq<WatchDescriptor> for WatchDescriptor

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

impl PartialEq<Handle> for Handle

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

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

impl PartialEq<UnparkToken> for UnparkToken

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

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

impl PartialEq<FilterOp> for FilterOp

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

impl PartialEq<UnparkResult> for UnparkResult

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

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

impl PartialEq<ParkToken> for ParkToken

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

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

impl PartialEq<RequeueOp> for RequeueOp

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

impl PartialEq<ParkResult> for ParkResult

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

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

impl<A, B> PartialEq<SmallVec<B>> for SmallVec<A> where
    B: Array,
    A: Array,
    <A as Array>::Item: PartialEq<<B as Array>::Item>, 

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

impl PartialEq<ExtMeta> for ExtMeta

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

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

impl PartialEq<Marker> for Marker

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

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

impl PartialEq<BigEndian> for BigEndian

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

impl PartialEq<LittleEndian> for LittleEndian

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

impl PartialEq<UnixSocketAddr> for [u8]

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

impl PartialEq<WeightedError> for WeightedError

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

impl PartialEq<IndexVec> for IndexVec

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

impl PartialEq<StdRng> for StdRng

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

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

impl PartialEq<StepRng> for StepRng

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

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

impl PartialEq<BernoulliError> for BernoulliError

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

impl PartialEq<Error> for Error

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

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

impl PartialEq<ChaCha20Rng> for ChaCha20Rng

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

impl PartialEq<ChaCha12Core> for ChaCha12Core

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

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

impl PartialEq<ChaCha20Core> for ChaCha20Core

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

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

impl PartialEq<ChaCha8Rng> for ChaCha8Rng

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

impl PartialEq<ChaCha8Core> for ChaCha8Core

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

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

impl PartialEq<ChaCha12Rng> for ChaCha12Rng

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

impl PartialEq<vec256_storage> for vec256_storage

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

impl PartialEq<vec128_storage> for vec128_storage

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

impl PartialEq<vec512_storage> for vec512_storage

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

impl PartialEq<ParseError> for ParseError

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

impl PartialEq<SyntaxViolation> for SyntaxViolation

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

impl<S, T> PartialEq<Host<T>> for Host<S> where
    S: PartialEq<T>, 

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

impl PartialEq<OpaqueOrigin> for OpaqueOrigin

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

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

impl PartialEq<Origin> for Origin

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

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

impl PartialEq<ParseError> for ParseError

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

impl PartialEq<Error> for Error

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

impl PartialEq<Level> for Level

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

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

impl<'a> PartialEq<String> for Level

Used for matching levels in conformance tests

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

impl<'text> PartialEq<BidiInfo<'text>> for BidiInfo<'text>

pub fn eq(&self, other: &BidiInfo<'text>) -> bool

pub fn ne(&self, other: &BidiInfo<'text>) -> bool

impl<'a> PartialEq<&'a str> for Level

Used for matching levels in conformance tests

pub fn eq(&self, s: &&'a str) -> bool

impl PartialEq<ParagraphInfo> for ParagraphInfo

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

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

impl PartialEq<BidiClass> for BidiClass

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

impl<'text> PartialEq<InitialInfo<'text>> for InitialInfo<'text>

pub fn eq(&self, other: &InitialInfo<'text>) -> bool

pub fn ne(&self, other: &InitialInfo<'text>) -> bool

impl PartialEq<IsNormalized> for IsNormalized

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

impl<'_, A> PartialEq<&'_ [<A as Array>::Item]> for TinyVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

pub fn eq(&self, other: &&[<A as Array>::Item]) -> bool

impl<'_, A> PartialEq<&'_ A> for TinyVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

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

impl<A> PartialEq<TinyVec<A>> for TinyVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

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

impl<'_, A> PartialEq<&'_ A> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

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

impl<A> PartialEq<ArrayVec<A>> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

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

impl<'_, A> PartialEq<&'_ [<A as Array>::Item]> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

#[must_use]

pub fn eq(&self, other: &&[<A as Array>::Item]) -> bool

impl<'s, '_, T> PartialEq<&'_ [T]> for SliceVec<'s, T> where
    T: PartialEq<T>, 

#[must_use]

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

impl<'s, T> PartialEq<SliceVec<'s, T>> for SliceVec<'s, T> where
    T: PartialEq<T>, 

#[must_use]

pub fn eq(&self, other: &SliceVec<'s, T>) -> bool

impl PartialEq<Block> for Block

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

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

impl PartialEq<MacroCall> for MacroCall

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

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

impl PartialEq<MacroDefinition> for MacroDefinition

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

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

impl PartialEq<LogicOperator> for LogicOperator

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

impl PartialEq<LogicExpr> for LogicExpr

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

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

impl PartialEq<If> for If

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

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

impl PartialEq<MathExpr> for MathExpr

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

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

impl PartialEq<Forloop> for Forloop

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

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

impl PartialEq<Node> for Node

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

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

impl PartialEq<Test> for Test

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

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

impl PartialEq<Context> for Context

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

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

impl PartialEq<StringConcat> for StringConcat

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

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

impl PartialEq<Set> for Set

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

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

impl PartialEq<ExprVal> for ExprVal

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

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

impl PartialEq<MathOperator> for MathOperator

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

impl PartialEq<FunctionCall> for FunctionCall

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

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

impl PartialEq<WS> for WS

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

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

impl PartialEq<FilterSection> for FilterSection

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

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

impl PartialEq<Expr> for Expr

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

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

impl PartialEq<Pattern> for Pattern

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

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

impl PartialEq<MatchOptions> for MatchOptions

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

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

impl PartialEq<InputLocation> for InputLocation

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

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

impl PartialEq<LineColLocation> for LineColLocation

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

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

impl PartialEq<MatchDir> for MatchDir

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

impl PartialEq<Lookahead> for Lookahead

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

impl PartialEq<Assoc> for Assoc

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

impl<R> PartialEq<Error<R>> for Error<R> where
    R: PartialEq<R>, 

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

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

impl<'i> PartialEq<Position<'i>> for Position<'i>

pub fn eq(&self, other: &Position<'i>) -> bool

impl<'i, R> PartialEq<Pairs<'i, R>> for Pairs<'i, R> where
    R: PartialEq<R>, 

pub fn eq(&self, other: &Pairs<'i, R>) -> bool

impl<'i, R> PartialEq<Token<'i, R>> for Token<'i, R> where
    R: PartialEq<R>, 

pub fn eq(&self, other: &Token<'i, R>) -> bool

pub fn ne(&self, other: &Token<'i, R>) -> bool

impl<'i, R> PartialEq<Pair<'i, R>> for Pair<'i, R> where
    R: PartialEq<R>, 

pub fn eq(&self, other: &Pair<'i, R>) -> bool

impl<'i> PartialEq<Span<'i>> for Span<'i>

pub fn eq(&self, other: &Span<'i>) -> bool

impl<R> PartialEq<ErrorVariant<R>> for ErrorVariant<R> where
    R: PartialEq<R>, 

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

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

impl PartialEq<Atomicity> for Atomicity

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

impl PartialEq<Kilo> for Kilo

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

impl<S> PartialEq<Host<S>> for Host<S> where
    S: PartialEq<S>, 

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

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

impl PartialEq<OpaqueOrigin> for OpaqueOrigin

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

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

impl PartialEq<SyntaxViolation> for SyntaxViolation

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

impl PartialEq<Url> for Url

URLs compare like their serialization.

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

impl PartialEq<ParseError> for ParseError

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

impl PartialEq<Origin> for Origin

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

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

impl PartialEq<GraphemeIncomplete> for GraphemeIncomplete

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

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

impl PartialEq<SentenceBreak> for SentenceBreak

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

impl PartialEq<WordBreak> for WordBreak

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

impl PartialEq<GraphemeClusterBreak> for GraphemeClusterBreak

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

impl PartialEq<CharRange> for CharRange

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

impl PartialEq<UnicodeVersion> for UnicodeVersion

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

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

impl<'a, 'b> PartialEq<Builder<'a, 'b>> for Builder<'a, 'b>

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

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

impl PartialEq<ErrorKind> for ErrorKind

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

impl PartialEq<ArgSettings> for ArgSettings

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

impl<'n, 'e> PartialEq<Arg<'n, 'e>> for Arg<'n, 'e>

pub fn eq(&self, other: &Arg<'n, 'e>) -> bool

impl PartialEq<AppSettings> for AppSettings

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

impl PartialEq<Style> for Style

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

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

impl PartialEq<Colour> for Colour

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

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

impl<'a, S> PartialEq<ANSIGenericString<'a, S>> for ANSIGenericString<'a, S> where
    S: 'a + PartialEq<S> + ToOwned + ?Sized,
    <S as ToOwned>::Owned: Debug, 

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

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

impl PartialEq<StrSimError> for StrSimError

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

impl<V> PartialEq<VecMap<V>> for VecMap<V> where
    V: PartialEq<V>, 

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

Loading content...

Implementors

impl PartialEq<AccountScope> for AccountScope

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

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

impl PartialEq<LinkKind> for LinkKind

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

impl PartialEq<OccDisplacement> for OccDisplacement

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

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

impl PartialEq<OccultationKindAlwaysOk> for OccultationKindAlwaysOk

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

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

impl PartialEq<OldNewIndex> for OldNewIndex

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

impl PartialEq<PieceMoveable> for PieceMoveable

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

impl PartialEq<PieceOpErrorPartiallyProcessed> for PieceOpErrorPartiallyProcessed

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

impl PartialEq<PresentationLayout> for PresentationLayout

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

impl PartialEq<StaticUser> for StaticUser

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

impl PartialEq<TablePermission> for TablePermission

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

impl PartialEq<VarError> for VarError

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

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

impl PartialEq<Level> for otter_api_tests::flexi_logger::Level

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

impl PartialEq<Level> for LevelFilter

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

impl PartialEq<LevelFilter> for otter_api_tests::flexi_logger::Level

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

impl PartialEq<LevelFilter> for LevelFilter

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

impl PartialEq<Month> for Month

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

impl PartialEq<RoundingError> for RoundingError

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

impl PartialEq<SecondsFormat> for SecondsFormat

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

impl PartialEq<Weekday> for Weekday

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

impl PartialEq<Fixed> for Fixed

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

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

impl PartialEq<Numeric> for Numeric

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

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

impl PartialEq<Pad> for Pad

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

impl PartialEq<Tz> for Tz

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

impl PartialEq<Target> for Target

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

impl PartialEq<WriteStyle> for WriteStyle

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

impl PartialEq<Color> for otter_api_tests::imports::env_logger::fmt::Color

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

pub fn ne(&self, other: &Color) -> 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<Ordering> for otter_api_tests::imports::failure::_core::sync::atomic::Ordering

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

impl PartialEq<Type> for Type

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

impl PartialEq<Error> for otter_api_tests::imports::nix::Error

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

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

impl PartialEq<Errno> for Errno

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

impl PartialEq<FlockArg> for FlockArg

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

impl PartialEq<PosixFadviseAdvice> for PosixFadviseAdvice

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

impl PartialEq<AioCancelStat> for AioCancelStat

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

impl PartialEq<AioFsyncMode> for AioFsyncMode

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

impl PartialEq<LioMode> for LioMode

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

impl PartialEq<LioOpcode> for LioOpcode

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

impl PartialEq<EpollOp> for EpollOp

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

impl PartialEq<MmapAdvise> for MmapAdvise

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

impl PartialEq<Event> for otter_api_tests::imports::nix::sys::ptrace::Event

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

impl PartialEq<Request> for Request

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

impl PartialEq<QuotaFmt> for QuotaFmt

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

impl PartialEq<QuotaType> for QuotaType

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

impl PartialEq<RebootMode> for RebootMode

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

impl PartialEq<SigHandler> for SigHandler

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

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

impl PartialEq<SigevNotify> for SigevNotify

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

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

impl PartialEq<SigmaskHow> for SigmaskHow

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

impl PartialEq<Signal> for Signal

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

impl PartialEq<AddressFamily> for AddressFamily

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

impl PartialEq<ControlMessageOwned> for ControlMessageOwned

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

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

impl PartialEq<InetAddr> for InetAddr

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

pub fn ne(&self, other: &InetAddr) -> bool

impl PartialEq<IpAddr> for otter_api_tests::imports::nix::sys::socket::IpAddr

pub fn eq(&self, other: &IpAddr) -> bool

pub fn ne(&self, other: &IpAddr) -> bool

impl PartialEq<Shutdown> for otter_api_tests::imports::nix::sys::socket::Shutdown

pub fn eq(&self, other: &Shutdown) -> bool

impl PartialEq<SockAddr> for SockAddr

pub fn eq(&self, other: &SockAddr) -> bool

pub fn ne(&self, other: &SockAddr) -> bool

impl PartialEq<SockProtocol> for SockProtocol

pub fn eq(&self, other: &SockProtocol) -> bool

impl PartialEq<SockType> for otter_api_tests::imports::nix::sys::socket::SockType

pub fn eq(&self, other: &SockType) -> bool

impl PartialEq<BaudRate> for BaudRate

pub fn eq(&self, other: &BaudRate) -> bool

impl PartialEq<FlowArg> for FlowArg

pub fn eq(&self, other: &FlowArg) -> bool

impl PartialEq<FlushArg> for FlushArg

pub fn eq(&self, other: &FlushArg) -> bool

impl PartialEq<SetArg> for SetArg

pub fn eq(&self, other: &SetArg) -> bool

impl PartialEq<SpecialCharacterIndices> for SpecialCharacterIndices

pub fn eq(&self, other: &SpecialCharacterIndices) -> bool

impl PartialEq<ClockId> for otter_api_tests::imports::nix::sys::timerfd::ClockId

pub fn eq(&self, other: &ClockId) -> bool

impl PartialEq<Expiration> for Expiration

pub fn eq(&self, other: &Expiration) -> bool

pub fn ne(&self, other: &Expiration) -> bool

impl PartialEq<WaitStatus> for WaitStatus

pub fn eq(&self, other: &WaitStatus) -> bool

pub fn ne(&self, other: &WaitStatus) -> bool

impl PartialEq<DecodeErrKind> for DecodeErrKind

pub fn eq(&self, other: &DecodeErrKind) -> bool

impl PartialEq<OnceState> for OnceState

pub fn eq(&self, other: &OnceState) -> bool

impl PartialEq<PwdError> for PwdError

pub fn eq(&self, other: &PwdError) -> bool

pub fn ne(&self, other: &PwdError) -> bool

impl PartialEq<Error> for otter_api_tests::imports::regex::Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<Value> for otter_api_tests::imports::toml::Value

pub fn eq(&self, other: &Value) -> bool

pub fn ne(&self, other: &Value) -> bool

impl PartialEq<Error> for otter_api_tests::imports::toml::ser::Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<ConnCredentials> for ConnCredentials

pub fn eq(&self, other: &ConnCredentials) -> bool

pub fn ne(&self, other: &ConnCredentials) -> bool

impl PartialEq<RecvTimeoutError> for RecvTimeoutError

pub fn eq(&self, other: &RecvTimeoutError) -> bool

impl PartialEq<TryRecvError> for TryRecvError

pub fn eq(&self, other: &TryRecvError) -> bool

impl PartialEq<Value> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &Value) -> bool

pub fn ne(&self, other: &Value) -> bool

impl PartialEq<Category> for Category

pub fn eq(&self, other: &Category) -> bool

impl PartialEq<ErrorKind> for otter_api_tests::shapelib::ErrorKind

pub fn eq(&self, other: &ErrorKind) -> bool

impl PartialEq<Infallible> for Infallible

pub fn eq(&self, &Infallible) -> bool

impl PartialEq<Ordering> for otter_api_tests::shapelib::Ordering

pub fn eq(&self, other: &Ordering) -> bool

impl PartialEq<SeekFrom> for SeekFrom

pub fn eq(&self, other: &SeekFrom) -> bool

pub fn ne(&self, other: &SeekFrom) -> bool

impl PartialEq<PieceLabelPlace> for PieceLabelPlace

pub fn eq(&self, other: &PieceLabelPlace) -> bool

impl PartialEq<SearchStep> for SearchStep

pub fn eq(&self, other: &SearchStep) -> bool

pub fn ne(&self, other: &SearchStep) -> bool

impl PartialEq<PathconfVar> for PathconfVar

pub fn eq(&self, other: &PathconfVar) -> bool

impl PartialEq<SysconfVar> for SysconfVar

pub fn eq(&self, other: &SysconfVar) -> bool

impl PartialEq<LogicError> for LogicError

pub fn eq(&self, other: &LogicError) -> bool

pub fn ne(&self, other: &LogicError) -> bool

impl PartialEq<bool> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &bool) -> bool

impl PartialEq<f32> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f32) -> bool

impl PartialEq<f64> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f64) -> bool

impl PartialEq<i8> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i8) -> bool

impl PartialEq<i16> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i16) -> bool

impl PartialEq<i32> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i32) -> bool

impl PartialEq<i64> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i64) -> bool

impl PartialEq<isize> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &isize) -> bool

impl PartialEq<[u8]> for UnixSocketAddr

pub fn eq(&self, unescaped: &[u8]) -> bool

impl PartialEq<str> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &str) -> bool

impl PartialEq<str> for OsStr

pub fn eq(&self, other: &str) -> bool

impl PartialEq<u8> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u8) -> bool

impl PartialEq<u16> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u16) -> bool

impl PartialEq<u32> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u32) -> bool

impl PartialEq<u64> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u64) -> bool

impl PartialEq<usize> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<usize> for DescId

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<usize> for SvgId

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<usize> for FaceId

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<usize> for Notch

pub fn eq(&self, other: &usize) -> bool

impl PartialEq<ModuleFilter> for ModuleFilter

pub fn eq(&self, other: &ModuleFilter) -> bool

pub fn ne(&self, other: &ModuleFilter) -> bool

impl PartialEq<Error> for otter_api_tests::fmt::Error

pub fn eq(&self, other: &Error) -> bool

impl PartialEq<FileType> for FileType

pub fn eq(&self, other: &FileType) -> bool

pub fn ne(&self, other: &FileType) -> bool

impl PartialEq<Permissions> for Permissions

pub fn eq(&self, other: &Permissions) -> bool

pub fn ne(&self, other: &Permissions) -> bool

impl PartialEq<InternalFixed> for InternalFixed

pub fn eq(&self, other: &InternalFixed) -> bool

pub fn ne(&self, other: &InternalFixed) -> bool

impl PartialEq<InternalNumeric> for InternalNumeric

pub fn eq(&self, _other: &InternalNumeric) -> bool

impl PartialEq<Parsed> for Parsed

pub fn eq(&self, other: &Parsed) -> bool

pub fn ne(&self, other: &Parsed) -> bool

impl PartialEq<Duration> for otter_api_tests::imports::chrono::Duration

pub fn eq(&self, other: &Duration) -> bool

pub fn ne(&self, other: &Duration) -> bool

impl PartialEq<FixedOffset> for FixedOffset

pub fn eq(&self, other: &FixedOffset) -> bool

pub fn ne(&self, other: &FixedOffset) -> bool

impl PartialEq<IsoWeek> for IsoWeek

pub fn eq(&self, other: &IsoWeek) -> bool

pub fn ne(&self, other: &IsoWeek) -> bool

impl PartialEq<NaiveDate> for NaiveDate

pub fn eq(&self, other: &NaiveDate) -> bool

pub fn ne(&self, other: &NaiveDate) -> bool

impl PartialEq<NaiveDateTime> for NaiveDateTime

pub fn eq(&self, other: &NaiveDateTime) -> bool

pub fn ne(&self, other: &NaiveDateTime) -> bool

impl PartialEq<NaiveTime> for NaiveTime

pub fn eq(&self, other: &NaiveTime) -> bool

pub fn ne(&self, other: &NaiveTime) -> bool

impl PartialEq<ParseError> for otter_api_tests::imports::chrono::ParseError

pub fn eq(&self, other: &ParseError) -> bool

pub fn ne(&self, other: &ParseError) -> bool

impl PartialEq<ParseMonthError> for ParseMonthError

pub fn eq(&self, other: &ParseMonthError) -> bool

pub fn ne(&self, other: &ParseMonthError) -> bool

impl PartialEq<ParseWeekdayError> for ParseWeekdayError

pub fn eq(&self, other: &ParseWeekdayError) -> bool

pub fn ne(&self, other: &ParseWeekdayError) -> bool

impl PartialEq<Utc> for Utc

pub fn eq(&self, other: &Utc) -> bool

impl PartialEq<AllocError> for AllocError

pub fn eq(&self, other: &AllocError) -> bool

impl PartialEq<Layout> for Layout

pub fn eq(&self, other: &Layout) -> bool

pub fn ne(&self, other: &Layout) -> bool

impl PartialEq<LayoutError> for LayoutError

pub fn eq(&self, other: &LayoutError) -> bool

pub fn ne(&self, other: &LayoutError) -> bool

impl PartialEq<TypeId> for TypeId

pub fn eq(&self, other: &TypeId) -> bool

pub fn ne(&self, other: &TypeId) -> bool

impl PartialEq<CpuidResult> for CpuidResult

pub fn eq(&self, other: &CpuidResult) -> bool

pub fn ne(&self, other: &CpuidResult) -> bool

impl PartialEq<CharTryFromError> for CharTryFromError

pub fn eq(&self, other: &CharTryFromError) -> bool

pub fn ne(&self, other: &CharTryFromError) -> bool

impl PartialEq<DecodeUtf16Error> for DecodeUtf16Error

pub fn eq(&self, other: &DecodeUtf16Error) -> bool

pub fn ne(&self, other: &DecodeUtf16Error) -> bool

impl PartialEq<ParseCharError> for ParseCharError

pub fn eq(&self, other: &ParseCharError) -> bool

pub fn ne(&self, other: &ParseCharError) -> bool

impl PartialEq<PhantomPinned> for PhantomPinned

pub fn eq(&self, other: &PhantomPinned) -> bool

impl PartialEq<NonZeroI8> for NonZeroI8

pub fn eq(&self, other: &NonZeroI8) -> bool

pub fn ne(&self, other: &NonZeroI8) -> bool

impl PartialEq<NonZeroI16> for NonZeroI16

pub fn eq(&self, other: &NonZeroI16) -> bool

pub fn ne(&self, other: &NonZeroI16) -> bool

impl PartialEq<NonZeroI32> for NonZeroI32

pub fn eq(&self, other: &NonZeroI32) -> bool

pub fn ne(&self, other: &NonZeroI32) -> bool

impl PartialEq<NonZeroI64> for NonZeroI64

pub fn eq(&self, other: &NonZeroI64) -> bool

pub fn ne(&self, other: &NonZeroI64) -> bool

impl PartialEq<NonZeroI128> for NonZeroI128

pub fn eq(&self, other: &NonZeroI128) -> bool

pub fn ne(&self, other: &NonZeroI128) -> bool

impl PartialEq<NonZeroIsize> for NonZeroIsize

pub fn eq(&self, other: &NonZeroIsize) -> bool

pub fn ne(&self, other: &NonZeroIsize) -> bool

impl PartialEq<NonZeroU8> for NonZeroU8

pub fn eq(&self, other: &NonZeroU8) -> bool

pub fn ne(&self, other: &NonZeroU8) -> bool

impl PartialEq<NonZeroU16> for NonZeroU16

pub fn eq(&self, other: &NonZeroU16) -> bool

pub fn ne(&self, other: &NonZeroU16) -> bool

impl PartialEq<NonZeroU32> for NonZeroU32

pub fn eq(&self, other: &NonZeroU32) -> bool

pub fn ne(&self, other: &NonZeroU32) -> bool

impl PartialEq<NonZeroU64> for NonZeroU64

pub fn eq(&self, other: &NonZeroU64) -> bool

pub fn ne(&self, other: &NonZeroU64) -> bool

impl PartialEq<NonZeroU128> for NonZeroU128

pub fn eq(&self, other: &NonZeroU128) -> bool

pub fn ne(&self, other: &NonZeroU128) -> bool

impl PartialEq<ParseFloatError> for ParseFloatError

pub fn eq(&self, other: &ParseFloatError) -> bool

pub fn ne(&self, other: &ParseFloatError) -> bool

impl PartialEq<ParseIntError> for ParseIntError

pub fn eq(&self, other: &ParseIntError) -> bool

pub fn ne(&self, other: &ParseIntError) -> bool

impl PartialEq<RangeFull> for RangeFull

pub fn eq(&self, other: &RangeFull) -> bool

impl PartialEq<NoneError> for NoneError

pub fn eq(&self, other: &NoneError) -> bool

impl PartialEq<RawWaker> for RawWaker

pub fn eq(&self, other: &RawWaker) -> bool

pub fn ne(&self, other: &RawWaker) -> bool

impl PartialEq<RawWakerVTable> for RawWakerVTable

pub fn eq(&self, other: &RawWakerVTable) -> bool

pub fn ne(&self, other: &RawWakerVTable) -> bool

impl PartialEq<FsStats> for FsStats

pub fn eq(&self, other: &FsStats) -> bool

pub fn ne(&self, other: &FsStats) -> bool

impl PartialEq<MatchOptions> for otter_api_tests::imports::glob::MatchOptions

pub fn eq(&self, other: &MatchOptions) -> bool

pub fn ne(&self, other: &MatchOptions) -> bool

impl PartialEq<Pattern> for otter_api_tests::imports::glob::Pattern

pub fn eq(&self, other: &Pattern) -> bool

pub fn ne(&self, other: &Pattern) -> bool

impl PartialEq<Dl_info> for Dl_info

pub fn eq(&self, other: &Dl_info) -> bool

pub fn ne(&self, other: &Dl_info) -> bool

impl PartialEq<Elf32_Chdr> for Elf32_Chdr

pub fn eq(&self, other: &Elf32_Chdr) -> bool

pub fn ne(&self, other: &Elf32_Chdr) -> bool

impl PartialEq<Elf32_Ehdr> for Elf32_Ehdr

pub fn eq(&self, other: &Elf32_Ehdr) -> bool

pub fn ne(&self, other: &Elf32_Ehdr) -> bool

impl PartialEq<Elf32_Phdr> for Elf32_Phdr

pub fn eq(&self, other: &Elf32_Phdr) -> bool

pub fn ne(&self, other: &Elf32_Phdr) -> bool

impl PartialEq<Elf32_Shdr> for Elf32_Shdr

pub fn eq(&self, other: &Elf32_Shdr) -> bool

pub fn ne(&self, other: &Elf32_Shdr) -> bool

impl PartialEq<Elf32_Sym> for Elf32_Sym

pub fn eq(&self, other: &Elf32_Sym) -> bool

pub fn ne(&self, other: &Elf32_Sym) -> bool

impl PartialEq<Elf64_Chdr> for Elf64_Chdr

pub fn eq(&self, other: &Elf64_Chdr) -> bool

pub fn ne(&self, other: &Elf64_Chdr) -> bool

impl PartialEq<Elf64_Ehdr> for Elf64_Ehdr

pub fn eq(&self, other: &Elf64_Ehdr) -> bool

pub fn ne(&self, other: &Elf64_Ehdr) -> bool

impl PartialEq<Elf64_Phdr> for Elf64_Phdr

pub fn eq(&self, other: &Elf64_Phdr) -> bool

pub fn ne(&self, other: &Elf64_Phdr) -> bool

impl PartialEq<Elf64_Shdr> for Elf64_Shdr

pub fn eq(&self, other: &Elf64_Shdr) -> bool

pub fn ne(&self, other: &Elf64_Shdr) -> bool

impl PartialEq<Elf64_Sym> for Elf64_Sym

pub fn eq(&self, other: &Elf64_Sym) -> bool

pub fn ne(&self, other: &Elf64_Sym) -> bool

impl PartialEq<__c_anonymous_sockaddr_can_j1939> for __c_anonymous_sockaddr_can_j1939

pub fn eq(&self, other: &__c_anonymous_sockaddr_can_j1939) -> bool

pub fn ne(&self, other: &__c_anonymous_sockaddr_can_j1939) -> bool

impl PartialEq<__c_anonymous_sockaddr_can_tp> for __c_anonymous_sockaddr_can_tp

pub fn eq(&self, other: &__c_anonymous_sockaddr_can_tp) -> bool

pub fn ne(&self, other: &__c_anonymous_sockaddr_can_tp) -> bool

impl PartialEq<__exit_status> for __exit_status

pub fn eq(&self, other: &__exit_status) -> bool

pub fn ne(&self, other: &__exit_status) -> bool

impl PartialEq<__timeval> for __timeval

pub fn eq(&self, other: &__timeval) -> bool

pub fn ne(&self, other: &__timeval) -> bool

impl PartialEq<_libc_fpstate> for _libc_fpstate

pub fn eq(&self, other: &_libc_fpstate) -> bool

pub fn ne(&self, other: &_libc_fpstate) -> bool

impl PartialEq<_libc_fpxreg> for _libc_fpxreg

pub fn eq(&self, other: &_libc_fpxreg) -> bool

pub fn ne(&self, other: &_libc_fpxreg) -> bool

impl PartialEq<_libc_xmmreg> for _libc_xmmreg

pub fn eq(&self, other: &_libc_xmmreg) -> bool

pub fn ne(&self, other: &_libc_xmmreg) -> bool

impl PartialEq<addrinfo> for addrinfo

pub fn eq(&self, other: &addrinfo) -> bool

pub fn ne(&self, other: &addrinfo) -> bool

impl PartialEq<af_alg_iv> for af_alg_iv

pub fn eq(&self, other: &af_alg_iv) -> bool

impl PartialEq<aiocb> for aiocb

pub fn eq(&self, other: &aiocb) -> bool

pub fn ne(&self, other: &aiocb) -> bool

impl PartialEq<arpd_request> for arpd_request

pub fn eq(&self, other: &arpd_request) -> bool

pub fn ne(&self, other: &arpd_request) -> bool

impl PartialEq<arphdr> for arphdr

pub fn eq(&self, other: &arphdr) -> bool

pub fn ne(&self, other: &arphdr) -> bool

impl PartialEq<arpreq> for arpreq

pub fn eq(&self, other: &arpreq) -> bool

pub fn ne(&self, other: &arpreq) -> bool

impl PartialEq<arpreq_old> for arpreq_old

pub fn eq(&self, other: &arpreq_old) -> bool

pub fn ne(&self, other: &arpreq_old) -> bool

impl PartialEq<can_filter> for can_filter

pub fn eq(&self, other: &can_filter) -> bool

pub fn ne(&self, other: &can_filter) -> bool

impl PartialEq<cpu_set_t> for cpu_set_t

pub fn eq(&self, other: &cpu_set_t) -> bool

pub fn ne(&self, other: &cpu_set_t) -> bool

impl PartialEq<dirent64> for dirent64

pub fn eq(&self, other: &dirent64) -> bool

impl PartialEq<dirent> for dirent

pub fn eq(&self, other: &dirent) -> bool

impl PartialEq<dl_phdr_info> for dl_phdr_info

pub fn eq(&self, other: &dl_phdr_info) -> bool

pub fn ne(&self, other: &dl_phdr_info) -> bool

impl PartialEq<dqblk> for dqblk

pub fn eq(&self, other: &dqblk) -> bool

pub fn ne(&self, other: &dqblk) -> bool

impl PartialEq<epoll_event> for epoll_event

pub fn eq(&self, other: &epoll_event) -> bool

impl PartialEq<fanotify_event_metadata> for fanotify_event_metadata

pub fn eq(&self, other: &fanotify_event_metadata) -> bool

pub fn ne(&self, other: &fanotify_event_metadata) -> bool

impl PartialEq<fanotify_response> for fanotify_response

pub fn eq(&self, other: &fanotify_response) -> bool

pub fn ne(&self, other: &fanotify_response) -> bool

impl PartialEq<fd_set> for fd_set

pub fn eq(&self, other: &fd_set) -> bool

pub fn ne(&self, other: &fd_set) -> bool

impl PartialEq<ff_condition_effect> for ff_condition_effect

pub fn eq(&self, other: &ff_condition_effect) -> bool

pub fn ne(&self, other: &ff_condition_effect) -> bool

impl PartialEq<ff_constant_effect> for ff_constant_effect

pub fn eq(&self, other: &ff_constant_effect) -> bool

pub fn ne(&self, other: &ff_constant_effect) -> bool

impl PartialEq<ff_effect> for ff_effect

pub fn eq(&self, other: &ff_effect) -> bool

pub fn ne(&self, other: &ff_effect) -> bool

impl PartialEq<ff_envelope> for ff_envelope

pub fn eq(&self, other: &ff_envelope) -> bool

pub fn ne(&self, other: &ff_envelope) -> bool

impl PartialEq<ff_periodic_effect> for ff_periodic_effect

pub fn eq(&self, other: &ff_periodic_effect) -> bool

pub fn ne(&self, other: &ff_periodic_effect) -> bool

impl PartialEq<ff_ramp_effect> for ff_ramp_effect

pub fn eq(&self, other: &ff_ramp_effect) -> bool

pub fn ne(&self, other: &ff_ramp_effect) -> bool

impl PartialEq<ff_replay> for ff_replay

pub fn eq(&self, other: &ff_replay) -> bool

pub fn ne(&self, other: &ff_replay) -> bool

impl PartialEq<ff_rumble_effect> for ff_rumble_effect

pub fn eq(&self, other: &ff_rumble_effect) -> bool

pub fn ne(&self, other: &ff_rumble_effect) -> bool

impl PartialEq<ff_trigger> for ff_trigger

pub fn eq(&self, other: &ff_trigger) -> bool

pub fn ne(&self, other: &ff_trigger) -> bool

impl PartialEq<flock64> for flock64

pub fn eq(&self, other: &flock64) -> bool

pub fn ne(&self, other: &flock64) -> bool

impl PartialEq<flock> for flock

pub fn eq(&self, other: &flock) -> bool

pub fn ne(&self, other: &flock) -> bool

impl PartialEq<fsid_t> for fsid_t

pub fn eq(&self, other: &fsid_t) -> bool

pub fn ne(&self, other: &fsid_t) -> bool

impl PartialEq<genlmsghdr> for genlmsghdr

pub fn eq(&self, other: &genlmsghdr) -> bool

pub fn ne(&self, other: &genlmsghdr) -> bool

impl PartialEq<glob64_t> for glob64_t

pub fn eq(&self, other: &glob64_t) -> bool

pub fn ne(&self, other: &glob64_t) -> bool

impl PartialEq<glob_t> for glob_t

pub fn eq(&self, other: &glob_t) -> bool

pub fn ne(&self, other: &glob_t) -> bool

impl PartialEq<group> for group

pub fn eq(&self, other: &group) -> bool

pub fn ne(&self, other: &group) -> bool

impl PartialEq<hostent> for hostent

pub fn eq(&self, other: &hostent) -> bool

pub fn ne(&self, other: &hostent) -> bool

impl PartialEq<if_nameindex> for if_nameindex

pub fn eq(&self, other: &if_nameindex) -> bool

pub fn ne(&self, other: &if_nameindex) -> bool

impl PartialEq<ifaddrs> for ifaddrs

pub fn eq(&self, other: &ifaddrs) -> bool

pub fn ne(&self, other: &ifaddrs) -> bool

impl PartialEq<in6_addr> for in6_addr

pub fn eq(&self, other: &in6_addr) -> bool

pub fn ne(&self, other: &in6_addr) -> bool

impl PartialEq<in6_pktinfo> for in6_pktinfo

pub fn eq(&self, other: &in6_pktinfo) -> bool

pub fn ne(&self, other: &in6_pktinfo) -> bool

impl PartialEq<in6_rtmsg> for in6_rtmsg

pub fn eq(&self, other: &in6_rtmsg) -> bool

pub fn ne(&self, other: &in6_rtmsg) -> bool

impl PartialEq<in_addr> for in_addr

pub fn eq(&self, other: &in_addr) -> bool

pub fn ne(&self, other: &in_addr) -> bool

impl PartialEq<in_pktinfo> for in_pktinfo

pub fn eq(&self, other: &in_pktinfo) -> bool

pub fn ne(&self, other: &in_pktinfo) -> bool

impl PartialEq<inotify_event> for inotify_event

pub fn eq(&self, other: &inotify_event) -> bool

pub fn ne(&self, other: &inotify_event) -> bool

impl PartialEq<input_absinfo> for input_absinfo

pub fn eq(&self, other: &input_absinfo) -> bool

pub fn ne(&self, other: &input_absinfo) -> bool

impl PartialEq<input_event> for input_event

pub fn eq(&self, other: &input_event) -> bool

pub fn ne(&self, other: &input_event) -> bool

impl PartialEq<input_id> for input_id

pub fn eq(&self, other: &input_id) -> bool

pub fn ne(&self, other: &input_id) -> bool

impl PartialEq<input_keymap_entry> for input_keymap_entry

pub fn eq(&self, other: &input_keymap_entry) -> bool

pub fn ne(&self, other: &input_keymap_entry) -> bool

impl PartialEq<input_mask> for input_mask

pub fn eq(&self, other: &input_mask) -> bool

pub fn ne(&self, other: &input_mask) -> bool

impl PartialEq<iovec> for iovec

pub fn eq(&self, other: &iovec) -> bool

pub fn ne(&self, other: &iovec) -> bool

impl PartialEq<ip_mreq> for ip_mreq

pub fn eq(&self, other: &ip_mreq) -> bool

pub fn ne(&self, other: &ip_mreq) -> bool

impl PartialEq<ip_mreq_source> for ip_mreq_source

pub fn eq(&self, other: &ip_mreq_source) -> bool

pub fn ne(&self, other: &ip_mreq_source) -> bool

impl PartialEq<ip_mreqn> for ip_mreqn

pub fn eq(&self, other: &ip_mreqn) -> bool

pub fn ne(&self, other: &ip_mreqn) -> bool

impl PartialEq<ipc_perm> for ipc_perm

pub fn eq(&self, other: &ipc_perm) -> bool

pub fn ne(&self, other: &ipc_perm) -> bool

impl PartialEq<ipv6_mreq> for ipv6_mreq

pub fn eq(&self, other: &ipv6_mreq) -> bool

pub fn ne(&self, other: &ipv6_mreq) -> bool

impl PartialEq<itimerspec> for itimerspec

pub fn eq(&self, other: &itimerspec) -> bool

pub fn ne(&self, other: &itimerspec) -> bool

impl PartialEq<itimerval> for itimerval

pub fn eq(&self, other: &itimerval) -> bool

pub fn ne(&self, other: &itimerval) -> bool

impl PartialEq<lconv> for lconv

pub fn eq(&self, other: &lconv) -> bool

pub fn ne(&self, other: &lconv) -> bool

impl PartialEq<linger> for linger

pub fn eq(&self, other: &linger) -> bool

pub fn ne(&self, other: &linger) -> bool

impl PartialEq<mallinfo> for mallinfo

pub fn eq(&self, other: &mallinfo) -> bool

pub fn ne(&self, other: &mallinfo) -> bool

impl PartialEq<mcontext_t> for mcontext_t

pub fn eq(&self, other: &mcontext_t) -> bool

pub fn ne(&self, other: &mcontext_t) -> bool

impl PartialEq<mmsghdr> for mmsghdr

pub fn eq(&self, other: &mmsghdr) -> bool

pub fn ne(&self, other: &mmsghdr) -> bool

impl PartialEq<mntent> for mntent

pub fn eq(&self, other: &mntent) -> bool

pub fn ne(&self, other: &mntent) -> bool

impl PartialEq<mq_attr> for mq_attr

pub fn eq(&self, other: &mq_attr) -> bool

impl PartialEq<msginfo> for msginfo

pub fn eq(&self, other: &msginfo) -> bool

pub fn ne(&self, other: &msginfo) -> bool

impl PartialEq<msqid_ds> for msqid_ds

pub fn eq(&self, other: &msqid_ds) -> bool

pub fn ne(&self, other: &msqid_ds) -> bool

impl PartialEq<nl_mmap_hdr> for nl_mmap_hdr

pub fn eq(&self, other: &nl_mmap_hdr) -> bool

pub fn ne(&self, other: &nl_mmap_hdr) -> bool

impl PartialEq<nl_mmap_req> for nl_mmap_req

pub fn eq(&self, other: &nl_mmap_req) -> bool

pub fn ne(&self, other: &nl_mmap_req) -> bool

impl PartialEq<nl_pktinfo> for nl_pktinfo

pub fn eq(&self, other: &nl_pktinfo) -> bool

pub fn ne(&self, other: &nl_pktinfo) -> bool

impl PartialEq<nlattr> for nlattr

pub fn eq(&self, other: &nlattr) -> bool

pub fn ne(&self, other: &nlattr) -> bool

impl PartialEq<nlmsgerr> for nlmsgerr

pub fn eq(&self, other: &nlmsgerr) -> bool

pub fn ne(&self, other: &nlmsgerr) -> bool

impl PartialEq<nlmsghdr> for nlmsghdr

pub fn eq(&self, other: &nlmsghdr) -> bool

pub fn ne(&self, other: &nlmsghdr) -> bool

impl PartialEq<ntptimeval> for ntptimeval

pub fn eq(&self, other: &ntptimeval) -> bool

pub fn ne(&self, other: &ntptimeval) -> bool

impl PartialEq<packet_mreq> for packet_mreq

pub fn eq(&self, other: &packet_mreq) -> bool

pub fn ne(&self, other: &packet_mreq) -> bool

impl PartialEq<passwd> for passwd

pub fn eq(&self, other: &passwd) -> bool

pub fn ne(&self, other: &passwd) -> bool

impl PartialEq<pollfd> for pollfd

pub fn eq(&self, other: &pollfd) -> bool

pub fn ne(&self, other: &pollfd) -> bool

impl PartialEq<posix_spawn_file_actions_t> for posix_spawn_file_actions_t

pub fn eq(&self, other: &posix_spawn_file_actions_t) -> bool

pub fn ne(&self, other: &posix_spawn_file_actions_t) -> bool

impl PartialEq<posix_spawnattr_t> for posix_spawnattr_t

pub fn eq(&self, other: &posix_spawnattr_t) -> bool

pub fn ne(&self, other: &posix_spawnattr_t) -> bool

impl PartialEq<protoent> for protoent

pub fn eq(&self, other: &protoent) -> bool

pub fn ne(&self, other: &protoent) -> bool

impl PartialEq<pthread_attr_t> for pthread_attr_t

pub fn eq(&self, other: &pthread_attr_t) -> bool

pub fn ne(&self, other: &pthread_attr_t) -> bool

impl PartialEq<pthread_cond_t> for pthread_cond_t

pub fn eq(&self, other: &pthread_cond_t) -> bool

impl PartialEq<pthread_condattr_t> for pthread_condattr_t

pub fn eq(&self, other: &pthread_condattr_t) -> bool

pub fn ne(&self, other: &pthread_condattr_t) -> bool

impl PartialEq<pthread_mutex_t> for pthread_mutex_t

pub fn eq(&self, other: &pthread_mutex_t) -> bool

impl PartialEq<pthread_mutexattr_t> for pthread_mutexattr_t

pub fn eq(&self, other: &pthread_mutexattr_t) -> bool

pub fn ne(&self, other: &pthread_mutexattr_t) -> bool

impl PartialEq<pthread_rwlock_t> for pthread_rwlock_t

pub fn eq(&self, other: &pthread_rwlock_t) -> bool

impl PartialEq<pthread_rwlockattr_t> for pthread_rwlockattr_t

pub fn eq(&self, other: &pthread_rwlockattr_t) -> bool

pub fn ne(&self, other: &pthread_rwlockattr_t) -> bool

impl PartialEq<regex_t> for regex_t

pub fn eq(&self, other: &regex_t) -> bool

pub fn ne(&self, other: &regex_t) -> bool

impl PartialEq<regmatch_t> for regmatch_t

pub fn eq(&self, other: &regmatch_t) -> bool

pub fn ne(&self, other: &regmatch_t) -> bool

impl PartialEq<rlimit64> for rlimit64

pub fn eq(&self, other: &rlimit64) -> bool

pub fn ne(&self, other: &rlimit64) -> bool

impl PartialEq<rlimit> for rlimit

pub fn eq(&self, other: &rlimit) -> bool

pub fn ne(&self, other: &rlimit) -> bool

impl PartialEq<rtentry> for rtentry

pub fn eq(&self, other: &rtentry) -> bool

pub fn ne(&self, other: &rtentry) -> bool

impl PartialEq<rusage> for rusage

pub fn eq(&self, other: &rusage) -> bool

pub fn ne(&self, other: &rusage) -> bool

impl PartialEq<sched_param> for sched_param

pub fn eq(&self, other: &sched_param) -> bool

pub fn ne(&self, other: &sched_param) -> bool

impl PartialEq<sem_t> for sem_t

pub fn eq(&self, other: &sem_t) -> bool

pub fn ne(&self, other: &sem_t) -> bool

impl PartialEq<sembuf> for sembuf

pub fn eq(&self, other: &sembuf) -> bool

pub fn ne(&self, other: &sembuf) -> bool

impl PartialEq<servent> for servent

pub fn eq(&self, other: &servent) -> bool

pub fn ne(&self, other: &servent) -> bool

impl PartialEq<shmid_ds> for shmid_ds

pub fn eq(&self, other: &shmid_ds) -> bool

pub fn ne(&self, other: &shmid_ds) -> bool

impl PartialEq<sigaction> for sigaction

pub fn eq(&self, other: &sigaction) -> bool

pub fn ne(&self, other: &sigaction) -> bool

impl PartialEq<sigevent> for sigevent

pub fn eq(&self, other: &sigevent) -> bool

impl PartialEq<siginfo_t> for siginfo_t

pub fn eq(&self, other: &siginfo_t) -> bool

pub fn ne(&self, other: &siginfo_t) -> bool

impl PartialEq<sigset_t> for sigset_t

pub fn eq(&self, other: &sigset_t) -> bool

pub fn ne(&self, other: &sigset_t) -> bool

impl PartialEq<sigval> for sigval

pub fn eq(&self, other: &sigval) -> bool

pub fn ne(&self, other: &sigval) -> bool

impl PartialEq<sock_extended_err> for sock_extended_err

pub fn eq(&self, other: &sock_extended_err) -> bool

pub fn ne(&self, other: &sock_extended_err) -> bool

impl PartialEq<sockaddr_alg> for sockaddr_alg

pub fn eq(&self, other: &sockaddr_alg) -> bool

impl PartialEq<sockaddr_ll> for sockaddr_ll

pub fn eq(&self, other: &sockaddr_ll) -> bool

pub fn ne(&self, other: &sockaddr_ll) -> bool

impl PartialEq<sockaddr_nl> for sockaddr_nl

pub fn eq(&self, other: &sockaddr_nl) -> bool

impl PartialEq<sockaddr_vm> for sockaddr_vm

pub fn eq(&self, other: &sockaddr_vm) -> bool

pub fn ne(&self, other: &sockaddr_vm) -> bool

impl PartialEq<spwd> for spwd

pub fn eq(&self, other: &spwd) -> bool

pub fn ne(&self, other: &spwd) -> bool

impl PartialEq<stack_t> for stack_t

pub fn eq(&self, other: &stack_t) -> bool

pub fn ne(&self, other: &stack_t) -> bool

impl PartialEq<stat64> for stat64

pub fn eq(&self, other: &stat64) -> bool

pub fn ne(&self, other: &stat64) -> bool

impl PartialEq<statfs64> for statfs64

pub fn eq(&self, other: &statfs64) -> bool

pub fn ne(&self, other: &statfs64) -> bool

impl PartialEq<statfs> for statfs

pub fn eq(&self, other: &statfs) -> bool

pub fn ne(&self, other: &statfs) -> bool

impl PartialEq<statvfs64> for statvfs64

pub fn eq(&self, other: &statvfs64) -> bool

pub fn ne(&self, other: &statvfs64) -> bool

impl PartialEq<statvfs> for statvfs

pub fn eq(&self, other: &statvfs) -> bool

pub fn ne(&self, other: &statvfs) -> bool

impl PartialEq<statx> for statx

pub fn eq(&self, other: &statx) -> bool

pub fn ne(&self, other: &statx) -> bool

impl PartialEq<statx_timestamp> for statx_timestamp

pub fn eq(&self, other: &statx_timestamp) -> bool

pub fn ne(&self, other: &statx_timestamp) -> bool

impl PartialEq<sysinfo> for sysinfo

pub fn eq(&self, other: &sysinfo) -> bool

pub fn ne(&self, other: &sysinfo) -> bool

impl PartialEq<termios2> for termios2

pub fn eq(&self, other: &termios2) -> bool

pub fn ne(&self, other: &termios2) -> bool

impl PartialEq<termios> for termios

pub fn eq(&self, other: &termios) -> bool

pub fn ne(&self, other: &termios) -> bool

impl PartialEq<timespec> for timespec

pub fn eq(&self, other: &timespec) -> bool

pub fn ne(&self, other: &timespec) -> bool

impl PartialEq<timeval> for timeval

pub fn eq(&self, other: &timeval) -> bool

pub fn ne(&self, other: &timeval) -> bool

impl PartialEq<timex> for timex

pub fn eq(&self, other: &timex) -> bool

pub fn ne(&self, other: &timex) -> bool

impl PartialEq<tm> for tm

pub fn eq(&self, other: &tm) -> bool

pub fn ne(&self, other: &tm) -> bool

impl PartialEq<tms> for tms

pub fn eq(&self, other: &tms) -> bool

pub fn ne(&self, other: &tms) -> bool

impl PartialEq<ucontext_t> for ucontext_t

pub fn eq(&self, other: &ucontext_t) -> bool

impl PartialEq<ucred> for ucred

pub fn eq(&self, other: &ucred) -> bool

pub fn ne(&self, other: &ucred) -> bool

impl PartialEq<uinput_abs_setup> for uinput_abs_setup

pub fn eq(&self, other: &uinput_abs_setup) -> bool

pub fn ne(&self, other: &uinput_abs_setup) -> bool

impl PartialEq<uinput_ff_erase> for uinput_ff_erase

pub fn eq(&self, other: &uinput_ff_erase) -> bool

pub fn ne(&self, other: &uinput_ff_erase) -> bool

impl PartialEq<uinput_ff_upload> for uinput_ff_upload

pub fn eq(&self, other: &uinput_ff_upload) -> bool

pub fn ne(&self, other: &uinput_ff_upload) -> bool

impl PartialEq<uinput_setup> for uinput_setup

pub fn eq(&self, other: &uinput_setup) -> bool

impl PartialEq<uinput_user_dev> for uinput_user_dev

pub fn eq(&self, other: &uinput_user_dev) -> bool

impl PartialEq<user> for user

pub fn eq(&self, other: &user) -> bool

pub fn ne(&self, other: &user) -> bool

impl PartialEq<user_fpregs_struct> for user_fpregs_struct

pub fn eq(&self, other: &user_fpregs_struct) -> bool

impl PartialEq<user_regs_struct> for user_regs_struct

pub fn eq(&self, other: &user_regs_struct) -> bool

pub fn ne(&self, other: &user_regs_struct) -> bool

impl PartialEq<utimbuf> for utimbuf

pub fn eq(&self, other: &utimbuf) -> bool

pub fn ne(&self, other: &utimbuf) -> bool

impl PartialEq<utmpx> for utmpx

pub fn eq(&self, other: &utmpx) -> bool

impl PartialEq<utsname> for utsname

pub fn eq(&self, other: &utsname) -> bool

impl PartialEq<ParseLevelError> for ParseLevelError

pub fn eq(&self, other: &ParseLevelError) -> bool

pub fn ne(&self, other: &ParseLevelError) -> bool

impl PartialEq<Dir> for Dir

pub fn eq(&self, other: &Dir) -> bool

pub fn ne(&self, other: &Dir) -> bool

impl PartialEq<Entry> for Entry

pub fn eq(&self, other: &Entry) -> bool

pub fn ne(&self, other: &Entry) -> bool

impl PartialEq<OwningIter> for OwningIter

pub fn eq(&self, other: &OwningIter) -> bool

pub fn ne(&self, other: &OwningIter) -> bool

impl PartialEq<AtFlags> for AtFlags

pub fn eq(&self, other: &AtFlags) -> bool

pub fn ne(&self, other: &AtFlags) -> bool

impl PartialEq<FallocateFlags> for FallocateFlags

pub fn eq(&self, other: &FallocateFlags) -> bool

pub fn ne(&self, other: &FallocateFlags) -> bool

impl PartialEq<FdFlag> for otter_api_tests::imports::nix::fcntl::FdFlag

pub fn eq(&self, other: &FdFlag) -> bool

pub fn ne(&self, other: &FdFlag) -> bool

impl PartialEq<OFlag> for OFlag

pub fn eq(&self, other: &OFlag) -> bool

pub fn ne(&self, other: &OFlag) -> bool

impl PartialEq<SealFlag> for SealFlag

pub fn eq(&self, other: &SealFlag) -> bool

pub fn ne(&self, other: &SealFlag) -> bool

impl PartialEq<SpliceFFlags> for SpliceFFlags

pub fn eq(&self, other: &SpliceFFlags) -> bool

pub fn ne(&self, other: &SpliceFFlags) -> bool

impl PartialEq<InterfaceAddress> for InterfaceAddress

pub fn eq(&self, other: &InterfaceAddress) -> bool

pub fn ne(&self, other: &InterfaceAddress) -> bool

impl PartialEq<InterfaceAddressIterator> for InterfaceAddressIterator

pub fn eq(&self, other: &InterfaceAddressIterator) -> bool

pub fn ne(&self, other: &InterfaceAddressIterator) -> bool

impl PartialEq<DeleteModuleFlags> for DeleteModuleFlags

pub fn eq(&self, other: &DeleteModuleFlags) -> bool

pub fn ne(&self, other: &DeleteModuleFlags) -> bool

impl PartialEq<ModuleInitFlags> for ModuleInitFlags

pub fn eq(&self, other: &ModuleInitFlags) -> bool

pub fn ne(&self, other: &ModuleInitFlags) -> bool

impl PartialEq<MntFlags> for MntFlags

pub fn eq(&self, other: &MntFlags) -> bool

pub fn ne(&self, other: &MntFlags) -> bool

impl PartialEq<MsFlags> for otter_api_tests::imports::nix::mount::MsFlags

pub fn eq(&self, other: &MsFlags) -> bool

pub fn ne(&self, other: &MsFlags) -> bool

impl PartialEq<FdFlag> for otter_api_tests::imports::nix::mqueue::FdFlag

pub fn eq(&self, other: &FdFlag) -> bool

pub fn ne(&self, other: &FdFlag) -> bool

impl PartialEq<MQ_OFlag> for MQ_OFlag

pub fn eq(&self, other: &MQ_OFlag) -> bool

pub fn ne(&self, other: &MQ_OFlag) -> bool

impl PartialEq<MqAttr> for MqAttr

pub fn eq(&self, other: &MqAttr) -> bool

pub fn ne(&self, other: &MqAttr) -> bool

impl PartialEq<InterfaceFlags> for InterfaceFlags

pub fn eq(&self, other: &InterfaceFlags) -> bool

pub fn ne(&self, other: &InterfaceFlags) -> bool

impl PartialEq<PollFd> for PollFd

pub fn eq(&self, other: &PollFd) -> bool

pub fn ne(&self, other: &PollFd) -> bool

impl PartialEq<PollFlags> for PollFlags

pub fn eq(&self, other: &PollFlags) -> bool

pub fn ne(&self, other: &PollFlags) -> bool

impl PartialEq<OpenptyResult> for OpenptyResult

pub fn eq(&self, other: &OpenptyResult) -> bool

pub fn ne(&self, other: &OpenptyResult) -> bool

impl PartialEq<PtyMaster> for PtyMaster

pub fn eq(&self, other: &PtyMaster) -> bool

pub fn ne(&self, other: &PtyMaster) -> bool

impl PartialEq<winsize> for winsize

pub fn eq(&self, other: &winsize) -> bool

pub fn ne(&self, other: &winsize) -> bool

impl PartialEq<CloneFlags> for CloneFlags

pub fn eq(&self, other: &CloneFlags) -> bool

pub fn ne(&self, other: &CloneFlags) -> bool

impl PartialEq<CpuSet> for CpuSet

pub fn eq(&self, other: &CpuSet) -> bool

pub fn ne(&self, other: &CpuSet) -> bool

impl PartialEq<EpollCreateFlags> for EpollCreateFlags

pub fn eq(&self, other: &EpollCreateFlags) -> bool

pub fn ne(&self, other: &EpollCreateFlags) -> bool

impl PartialEq<EpollEvent> for EpollEvent

pub fn eq(&self, other: &EpollEvent) -> bool

pub fn ne(&self, other: &EpollEvent) -> bool

impl PartialEq<EpollFlags> for EpollFlags

pub fn eq(&self, other: &EpollFlags) -> bool

pub fn ne(&self, other: &EpollFlags) -> bool

impl PartialEq<EfdFlags> for EfdFlags

pub fn eq(&self, other: &EfdFlags) -> bool

pub fn ne(&self, other: &EfdFlags) -> bool

impl PartialEq<AddWatchFlags> for AddWatchFlags

pub fn eq(&self, other: &AddWatchFlags) -> bool

pub fn ne(&self, other: &AddWatchFlags) -> bool

impl PartialEq<InitFlags> for InitFlags

pub fn eq(&self, other: &InitFlags) -> bool

pub fn ne(&self, other: &InitFlags) -> bool

impl PartialEq<WatchDescriptor> for otter_api_tests::imports::nix::sys::inotify::WatchDescriptor

pub fn eq(&self, other: &WatchDescriptor) -> bool

pub fn ne(&self, other: &WatchDescriptor) -> bool

impl PartialEq<MemFdCreateFlag> for MemFdCreateFlag

pub fn eq(&self, other: &MemFdCreateFlag) -> bool

pub fn ne(&self, other: &MemFdCreateFlag) -> bool

impl PartialEq<MRemapFlags> for MRemapFlags

pub fn eq(&self, other: &MRemapFlags) -> bool

pub fn ne(&self, other: &MRemapFlags) -> bool

impl PartialEq<MapFlags> for MapFlags

pub fn eq(&self, other: &MapFlags) -> bool

pub fn ne(&self, other: &MapFlags) -> bool

impl PartialEq<MlockAllFlags> for MlockAllFlags

pub fn eq(&self, other: &MlockAllFlags) -> bool

pub fn ne(&self, other: &MlockAllFlags) -> bool

impl PartialEq<MsFlags> for otter_api_tests::imports::nix::sys::mman::MsFlags

pub fn eq(&self, other: &MsFlags) -> bool

pub fn ne(&self, other: &MsFlags) -> bool

impl PartialEq<ProtFlags> for ProtFlags

pub fn eq(&self, other: &ProtFlags) -> bool

pub fn ne(&self, other: &ProtFlags) -> bool

impl PartialEq<Persona> for Persona

pub fn eq(&self, other: &Persona) -> bool

pub fn ne(&self, other: &Persona) -> bool

impl PartialEq<Options> for Options

pub fn eq(&self, other: &Options) -> bool

pub fn ne(&self, other: &Options) -> bool

impl PartialEq<Dqblk> for Dqblk

pub fn eq(&self, other: &Dqblk) -> bool

pub fn ne(&self, other: &Dqblk) -> bool

impl PartialEq<QuotaValidFlags> for QuotaValidFlags

pub fn eq(&self, other: &QuotaValidFlags) -> bool

pub fn ne(&self, other: &QuotaValidFlags) -> bool

impl PartialEq<FdSet> for FdSet

pub fn eq(&self, other: &FdSet) -> bool

pub fn ne(&self, other: &FdSet) -> bool

impl PartialEq<SaFlags> for SaFlags

pub fn eq(&self, other: &SaFlags) -> bool

pub fn ne(&self, other: &SaFlags) -> bool

impl PartialEq<SigAction> for SigAction

pub fn eq(&self, other: &SigAction) -> bool

pub fn ne(&self, other: &SigAction) -> bool

impl PartialEq<SigEvent> for SigEvent

pub fn eq(&self, other: &SigEvent) -> bool

pub fn ne(&self, other: &SigEvent) -> bool

impl PartialEq<SignalIterator> for SignalIterator

pub fn eq(&self, other: &SignalIterator) -> bool

pub fn ne(&self, other: &SignalIterator) -> bool

impl PartialEq<SfdFlags> for SfdFlags

pub fn eq(&self, other: &SfdFlags) -> bool

pub fn ne(&self, other: &SfdFlags) -> bool

impl PartialEq<SigSet> for SigSet

pub fn eq(&self, other: &SigSet) -> bool

pub fn ne(&self, other: &SigSet) -> bool

impl PartialEq<SignalFd> for SignalFd

pub fn eq(&self, other: &SignalFd) -> bool

pub fn ne(&self, other: &SignalFd) -> bool

impl PartialEq<signalfd_siginfo> for signalfd_siginfo

pub fn eq(&self, other: &signalfd_siginfo) -> bool

pub fn ne(&self, other: &signalfd_siginfo) -> bool

impl PartialEq<AcceptConn> for AcceptConn

pub fn eq(&self, other: &AcceptConn) -> bool

impl PartialEq<BindToDevice> for BindToDevice

pub fn eq(&self, other: &BindToDevice) -> bool

impl PartialEq<Broadcast> for Broadcast

pub fn eq(&self, other: &Broadcast) -> bool

impl PartialEq<IpAddMembership> for IpAddMembership

pub fn eq(&self, other: &IpAddMembership) -> bool

impl PartialEq<IpDropMembership> for IpDropMembership

pub fn eq(&self, other: &IpDropMembership) -> bool

impl PartialEq<IpMulticastLoop> for IpMulticastLoop

pub fn eq(&self, other: &IpMulticastLoop) -> bool

impl PartialEq<IpMulticastTtl> for IpMulticastTtl

pub fn eq(&self, other: &IpMulticastTtl) -> bool

impl PartialEq<IpTransparent> for IpTransparent

pub fn eq(&self, other: &IpTransparent) -> bool

impl PartialEq<Ipv4PacketInfo> for Ipv4PacketInfo

pub fn eq(&self, other: &Ipv4PacketInfo) -> bool

impl PartialEq<Ipv6AddMembership> for Ipv6AddMembership

pub fn eq(&self, other: &Ipv6AddMembership) -> bool

impl PartialEq<Ipv6DropMembership> for Ipv6DropMembership

pub fn eq(&self, other: &Ipv6DropMembership) -> bool

impl PartialEq<Ipv6RecvPacketInfo> for Ipv6RecvPacketInfo

pub fn eq(&self, other: &Ipv6RecvPacketInfo) -> bool

impl PartialEq<KeepAlive> for KeepAlive

pub fn eq(&self, other: &KeepAlive) -> bool

impl PartialEq<Linger> for Linger

pub fn eq(&self, other: &Linger) -> bool

impl PartialEq<Mark> for Mark

pub fn eq(&self, other: &Mark) -> bool

impl PartialEq<OobInline> for OobInline

pub fn eq(&self, other: &OobInline) -> bool

impl PartialEq<OriginalDst> for OriginalDst

pub fn eq(&self, other: &OriginalDst) -> bool

impl PartialEq<PassCred> for PassCred

pub fn eq(&self, other: &PassCred) -> bool

impl PartialEq<PeerCredentials> for PeerCredentials

pub fn eq(&self, other: &PeerCredentials) -> bool

impl PartialEq<RcvBuf> for RcvBuf

pub fn eq(&self, other: &RcvBuf) -> bool

impl PartialEq<RcvBufForce> for RcvBufForce

pub fn eq(&self, other: &RcvBufForce) -> bool

impl PartialEq<ReceiveTimeout> for ReceiveTimeout

pub fn eq(&self, other: &ReceiveTimeout) -> bool

impl PartialEq<ReceiveTimestamp> for ReceiveTimestamp

pub fn eq(&self, other: &ReceiveTimestamp) -> bool

impl PartialEq<ReuseAddr> for ReuseAddr

pub fn eq(&self, other: &ReuseAddr) -> bool

impl PartialEq<ReusePort> for ReusePort

pub fn eq(&self, other: &ReusePort) -> bool

impl PartialEq<SendTimeout> for SendTimeout

pub fn eq(&self, other: &SendTimeout) -> bool

impl PartialEq<SndBuf> for SndBuf

pub fn eq(&self, other: &SndBuf) -> bool

impl PartialEq<SndBufForce> for SndBufForce

pub fn eq(&self, other: &SndBufForce) -> bool

impl PartialEq<SockType> for otter_api_tests::imports::nix::sys::socket::sockopt::SockType

pub fn eq(&self, other: &SockType) -> bool

impl PartialEq<SocketError> for SocketError

pub fn eq(&self, other: &SocketError) -> bool

impl PartialEq<TcpCongestion> for TcpCongestion

pub fn eq(&self, other: &TcpCongestion) -> bool

impl PartialEq<TcpKeepCount> for TcpKeepCount

pub fn eq(&self, other: &TcpKeepCount) -> bool

impl PartialEq<TcpKeepIdle> for TcpKeepIdle

pub fn eq(&self, other: &TcpKeepIdle) -> bool

impl PartialEq<TcpKeepInterval> for TcpKeepInterval

pub fn eq(&self, other: &TcpKeepInterval) -> bool

impl PartialEq<TcpNoDelay> for TcpNoDelay

pub fn eq(&self, other: &TcpNoDelay) -> bool

impl PartialEq<UdpGroSegment> for UdpGroSegment

pub fn eq(&self, other: &UdpGroSegment) -> bool

impl PartialEq<UdpGsoSegment> for UdpGsoSegment

pub fn eq(&self, other: &UdpGsoSegment) -> bool

impl PartialEq<AlgAddr> for AlgAddr

pub fn eq(&self, other: &AlgAddr) -> bool

impl PartialEq<IpMembershipRequest> for IpMembershipRequest

pub fn eq(&self, other: &IpMembershipRequest) -> bool

pub fn ne(&self, other: &IpMembershipRequest) -> bool

impl PartialEq<Ipv4Addr> for otter_api_tests::imports::nix::sys::socket::Ipv4Addr

pub fn eq(&self, other: &Ipv4Addr) -> bool

pub fn ne(&self, other: &Ipv4Addr) -> bool

impl PartialEq<Ipv6Addr> for otter_api_tests::imports::nix::sys::socket::Ipv6Addr

pub fn eq(&self, other: &Ipv6Addr) -> bool

pub fn ne(&self, other: &Ipv6Addr) -> bool

impl PartialEq<Ipv6MembershipRequest> for Ipv6MembershipRequest

pub fn eq(&self, other: &Ipv6MembershipRequest) -> bool

pub fn ne(&self, other: &Ipv6MembershipRequest) -> bool

impl PartialEq<LinkAddr> for LinkAddr

pub fn eq(&self, other: &LinkAddr) -> bool

pub fn ne(&self, other: &LinkAddr) -> bool

impl PartialEq<MsgFlags> for MsgFlags

pub fn eq(&self, other: &MsgFlags) -> bool

pub fn ne(&self, other: &MsgFlags) -> bool

impl PartialEq<NetlinkAddr> for NetlinkAddr

pub fn eq(&self, other: &NetlinkAddr) -> bool

pub fn ne(&self, other: &NetlinkAddr) -> bool

impl PartialEq<SockFlag> for SockFlag

pub fn eq(&self, other: &SockFlag) -> bool

pub fn ne(&self, other: &SockFlag) -> bool

impl PartialEq<UnixAddr> for UnixAddr

pub fn eq(&self, other: &UnixAddr) -> bool

impl PartialEq<UnixCredentials> for UnixCredentials

pub fn eq(&self, other: &UnixCredentials) -> bool

pub fn ne(&self, other: &UnixCredentials) -> bool

impl PartialEq<VsockAddr> for VsockAddr

pub fn eq(&self, other: &VsockAddr) -> bool

impl PartialEq<cmsghdr> for cmsghdr

pub fn eq(&self, other: &cmsghdr) -> bool

pub fn ne(&self, other: &cmsghdr) -> bool

impl PartialEq<msghdr> for msghdr

pub fn eq(&self, other: &msghdr) -> bool

pub fn ne(&self, other: &msghdr) -> bool

impl PartialEq<sockaddr> for sockaddr

pub fn eq(&self, other: &sockaddr) -> bool

pub fn ne(&self, other: &sockaddr) -> bool

impl PartialEq<sockaddr_in6> for sockaddr_in6

pub fn eq(&self, other: &sockaddr_in6) -> bool

pub fn ne(&self, other: &sockaddr_in6) -> bool

impl PartialEq<sockaddr_in> for sockaddr_in

pub fn eq(&self, other: &sockaddr_in) -> bool

pub fn ne(&self, other: &sockaddr_in) -> bool

impl PartialEq<sockaddr_storage> for sockaddr_storage

pub fn eq(&self, other: &sockaddr_storage) -> bool

impl PartialEq<sockaddr_un> for sockaddr_un

pub fn eq(&self, other: &sockaddr_un) -> bool

impl PartialEq<stat> for stat

pub fn eq(&self, other: &stat) -> bool

pub fn ne(&self, other: &stat) -> bool

impl PartialEq<Mode> for Mode

pub fn eq(&self, other: &Mode) -> bool

pub fn ne(&self, other: &Mode) -> bool

impl PartialEq<SFlag> for SFlag

pub fn eq(&self, other: &SFlag) -> bool

pub fn ne(&self, other: &SFlag) -> bool

impl PartialEq<FsType> for FsType

pub fn eq(&self, other: &FsType) -> bool

pub fn ne(&self, other: &FsType) -> bool

impl PartialEq<FsFlags> for FsFlags

pub fn eq(&self, other: &FsFlags) -> bool

pub fn ne(&self, other: &FsFlags) -> bool

impl PartialEq<Statvfs> for Statvfs

pub fn eq(&self, other: &Statvfs) -> bool

pub fn ne(&self, other: &Statvfs) -> bool

impl PartialEq<SysInfo> for SysInfo

pub fn eq(&self, other: &SysInfo) -> bool

pub fn ne(&self, other: &SysInfo) -> bool

impl PartialEq<ControlFlags> for ControlFlags

pub fn eq(&self, other: &ControlFlags) -> bool

pub fn ne(&self, other: &ControlFlags) -> bool

impl PartialEq<InputFlags> for InputFlags

pub fn eq(&self, other: &InputFlags) -> bool

pub fn ne(&self, other: &InputFlags) -> bool

impl PartialEq<LocalFlags> for LocalFlags

pub fn eq(&self, other: &LocalFlags) -> bool

pub fn ne(&self, other: &LocalFlags) -> bool

impl PartialEq<OutputFlags> for OutputFlags

pub fn eq(&self, other: &OutputFlags) -> bool

pub fn ne(&self, other: &OutputFlags) -> bool

impl PartialEq<Termios> for Termios

pub fn eq(&self, other: &Termios) -> bool

pub fn ne(&self, other: &Termios) -> bool

impl PartialEq<TimeVal> for TimeVal

pub fn eq(&self, other: &TimeVal) -> bool

pub fn ne(&self, other: &TimeVal) -> bool

impl PartialEq<TimerFlags> for TimerFlags

pub fn eq(&self, other: &TimerFlags) -> bool

pub fn ne(&self, other: &TimerFlags) -> bool

impl PartialEq<TimerSetTimeFlags> for TimerSetTimeFlags

pub fn eq(&self, other: &TimerSetTimeFlags) -> bool

pub fn ne(&self, other: &TimerSetTimeFlags) -> bool

impl PartialEq<RemoteIoVec> for RemoteIoVec

pub fn eq(&self, other: &RemoteIoVec) -> bool

pub fn ne(&self, other: &RemoteIoVec) -> bool

impl PartialEq<UtsName> for UtsName

pub fn eq(&self, other: &UtsName) -> bool

pub fn ne(&self, other: &UtsName) -> bool

impl PartialEq<WaitPidFlag> for WaitPidFlag

pub fn eq(&self, other: &WaitPidFlag) -> bool

pub fn ne(&self, other: &WaitPidFlag) -> bool

impl PartialEq<ClockId> for otter_api_tests::imports::nix::time::ClockId

pub fn eq(&self, other: &ClockId) -> bool

pub fn ne(&self, other: &ClockId) -> bool

impl PartialEq<UContext> for UContext

pub fn eq(&self, other: &UContext) -> bool

pub fn ne(&self, other: &UContext) -> bool

impl PartialEq<FloatIsNan> for FloatIsNan

pub fn eq(&self, other: &FloatIsNan) -> bool

impl PartialEq<DecodeErr> for DecodeErr

pub fn eq(&self, other: &DecodeErr) -> bool

pub fn ne(&self, other: &DecodeErr) -> bool

impl PartialEq<Error> for otter_api_tests::imports::otter_base::imports::serde::de::value::Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<WaitTimeoutResult> for otter_api_tests::imports::parking_lot::WaitTimeoutResult

pub fn eq(&self, other: &WaitTimeoutResult) -> bool

pub fn ne(&self, other: &WaitTimeoutResult) -> bool

impl PartialEq<Passwd> for Passwd

pub fn eq(&self, other: &Passwd) -> bool

pub fn ne(&self, other: &Passwd) -> bool

impl PartialEq<Raw> for Raw

pub fn eq(&self, other: &Raw) -> bool

pub fn ne(&self, other: &Raw) -> bool

impl PartialEq<DefaultKey> for DefaultKey

pub fn eq(&self, other: &DefaultKey) -> bool

pub fn ne(&self, other: &DefaultKey) -> bool

impl PartialEq<KeyData> for KeyData

pub fn eq(&self, other: &KeyData) -> bool

pub fn ne(&self, other: &KeyData) -> bool

impl PartialEq<Error> for otter_api_tests::imports::toml::de::Error

pub fn eq(&self, other: &Error) -> bool

pub fn ne(&self, other: &Error) -> bool

impl PartialEq<Datetime> for Datetime

pub fn eq(&self, other: &Datetime) -> bool

pub fn ne(&self, other: &Datetime) -> bool

impl PartialEq<Map<String, Value>> for otter_api_tests::imports::toml::value::Map<String, Value>

pub fn eq(&self, other: &Map<String, Value>) -> bool

impl PartialEq<UnixSocketAddr> for UnixSocketAddr

pub fn eq(&self, other: &UnixSocketAddr) -> bool

impl PartialEq<RecvError> for RecvError

pub fn eq(&self, other: &RecvError) -> bool

impl PartialEq<Map<String, Value>> for otter_api_tests::serde_json::Map<String, Value>

pub fn eq(&self, other: &Map<String, Value>) -> bool

impl PartialEq<Number> for Number

pub fn eq(&self, other: &Number) -> bool

pub fn ne(&self, other: &Number) -> bool

impl PartialEq<UpdateId> for UpdateId

pub fn eq(&self, other: &UpdateId) -> bool

pub fn ne(&self, other: &UpdateId) -> bool

impl PartialEq<DescId> for DescId

pub fn eq(&self, other: &DescId) -> bool

pub fn ne(&self, other: &DescId) -> bool

impl PartialEq<Duration> for otter_api_tests::shapelib::Duration

pub fn eq(&self, other: &Duration) -> bool

pub fn ne(&self, other: &Duration) -> bool

impl PartialEq<Instant> for Instant

pub fn eq(&self, other: &Instant) -> bool

pub fn ne(&self, other: &Instant) -> bool

impl PartialEq<ItemEnquiryData> for ItemEnquiryData

pub fn eq(&self, other: &ItemEnquiryData) -> bool

pub fn ne(&self, other: &ItemEnquiryData) -> bool

impl PartialEq<NonZeroUsize> for NonZeroUsize

pub fn eq(&self, other: &NonZeroUsize) -> bool

pub fn ne(&self, other: &NonZeroUsize) -> bool

impl PartialEq<OsStr> for OsStr

pub fn eq(&self, other: &OsStr) -> bool

impl PartialEq<PathBuf> for PathBuf

pub fn eq(&self, other: &PathBuf) -> bool

impl PartialEq<SvgId> for SvgId

pub fn eq(&self, other: &SvgId) -> bool

pub fn ne(&self, other: &SvgId) -> bool

impl PartialEq<TimeSpec> for TimeSpec

pub fn eq(&self, other: &TimeSpec) -> bool

pub fn ne(&self, other: &TimeSpec) -> bool

impl PartialEq<TryFromIntError> for TryFromIntError

pub fn eq(&self, other: &TryFromIntError) -> bool

pub fn ne(&self, other: &TryFromIntError) -> bool

impl PartialEq<Uid> for Uid

pub fn eq(&self, other: &Uid) -> bool

pub fn ne(&self, other: &Uid) -> bool

impl PartialEq<Url> for otter_api_tests::shapelib::Url

URLs compare like their serialization.

pub fn eq(&self, other: &Url) -> bool

impl PartialEq<ZCoord> for ZCoord

pub fn eq(&self, other: &ZCoord) -> bool

impl PartialEq<ParseBoolError> for ParseBoolError

pub fn eq(&self, other: &ParseBoolError) -> bool

pub fn ne(&self, other: &ParseBoolError) -> bool

impl PartialEq<Utf8Error> for Utf8Error

pub fn eq(&self, other: &Utf8Error) -> bool

pub fn ne(&self, other: &Utf8Error) -> bool

impl PartialEq<AccountId> for AccountId

pub fn eq(&self, other: &AccountId) -> bool

pub fn ne(&self, other: &AccountId) -> bool

impl PartialEq<AccountName> for AccountName

pub fn eq(&self, other: &AccountName) -> bool

pub fn ne(&self, other: &AccountName) -> bool

impl PartialEq<AccountNotFound> for AccountNotFound

pub fn eq(&self, other: &AccountNotFound) -> bool

impl PartialEq<ClientId> for ClientId

pub fn eq(&self, other: &ClientId) -> bool

pub fn ne(&self, other: &ClientId) -> bool

impl PartialEq<ClientSequence> for ClientSequence

pub fn eq(&self, other: &ClientSequence) -> bool

pub fn ne(&self, other: &ClientSequence) -> bool

impl PartialEq<CompassAngle> for CompassAngle

pub fn eq(&self, other: &CompassAngle) -> bool

pub fn ne(&self, other: &CompassAngle) -> bool

impl PartialEq<FaceId> for FaceId

pub fn eq(&self, other: &FaceId) -> bool

pub fn ne(&self, other: &FaceId) -> bool

impl PartialEq<FooParseError> for FooParseError

pub fn eq(&self, other: &FooParseError) -> bool

impl PartialEq<Generation> for Generation

pub fn eq(&self, other: &Generation) -> bool

pub fn ne(&self, other: &Generation) -> bool

impl PartialEq<GoodItemName> for GoodItemName

pub fn eq(&self, other: &GoodItemName) -> bool

pub fn ne(&self, other: &GoodItemName) -> bool

impl PartialEq<Html> for Html

pub fn eq(&self, other: &Html) -> bool

pub fn ne(&self, other: &Html) -> bool

impl PartialEq<HtmlLit> for HtmlLit

pub fn eq(&self, other: &HtmlLit) -> bool

pub fn ne(&self, other: &HtmlLit) -> bool

impl PartialEq<HtmlStr> for HtmlStr

pub fn eq(&self, other: &HtmlStr) -> bool

pub fn ne(&self, other: &HtmlStr) -> bool

impl PartialEq<InstanceName> for InstanceName

pub fn eq(&self, other: &InstanceName) -> bool

pub fn ne(&self, other: &InstanceName) -> bool

impl PartialEq<Notch> for Notch

pub fn eq(&self, other: &Notch) -> bool

pub fn ne(&self, other: &Notch) -> bool

impl PartialEq<OccId> for OccId

pub fn eq(&self, other: &OccId) -> bool

pub fn ne(&self, other: &OccId) -> bool

impl PartialEq<OccultIlkId> for OccultIlkId

pub fn eq(&self, other: &OccultIlkId) -> bool

pub fn ne(&self, other: &OccultIlkId) -> bool

impl PartialEq<OccultIlkName> for OccultIlkName

pub fn eq(&self, other: &OccultIlkName) -> bool

pub fn ne(&self, other: &OccultIlkName) -> bool

impl PartialEq<PieceId> for PieceId

pub fn eq(&self, other: &PieceId) -> bool

pub fn ne(&self, other: &PieceId) -> bool

impl PartialEq<PlayerId> for PlayerId

pub fn eq(&self, other: &PlayerId) -> bool

pub fn ne(&self, other: &PlayerId) -> bool

impl PartialEq<PlayerNotFound> for PlayerNotFound

pub fn eq(&self, other: &PlayerNotFound) -> bool

impl PartialEq<RawToken> for RawToken

pub fn eq(&self, other: &RawToken) -> bool

pub fn ne(&self, other: &RawToken) -> bool

impl PartialEq<RawTokenVal> for RawTokenVal

pub fn eq(&self, other: &RawTokenVal) -> bool

pub fn ne(&self, other: &RawTokenVal) -> bool

impl PartialEq<Timestamp> for otter_api_tests::Timestamp

pub fn eq(&self, other: &Timestamp) -> bool

pub fn ne(&self, other: &Timestamp) -> bool

impl PartialEq<TokenRevelationKey> for TokenRevelationKey

pub fn eq(&self, other: &TokenRevelationKey) -> bool

pub fn ne(&self, other: &TokenRevelationKey) -> bool

impl PartialEq<UrlSpec> for UrlSpec

pub fn eq(&self, other: &UrlSpec) -> bool

pub fn ne(&self, other: &UrlSpec) -> bool

impl PartialEq<VisiblePieceId> for VisiblePieceId

pub fn eq(&self, other: &VisiblePieceId) -> bool

pub fn ne(&self, other: &VisiblePieceId) -> bool

impl PartialEq<ZLevel> for ZLevel

pub fn eq(&self, other: &ZLevel) -> bool

pub fn ne(&self, other: &ZLevel) -> bool

impl PartialEq<AccessError> for AccessError

pub fn eq(&self, other: &AccessError) -> bool

pub fn ne(&self, other: &AccessError) -> bool

impl PartialEq<ThreadId> for ThreadId

pub fn eq(&self, other: &ThreadId) -> bool

pub fn ne(&self, other: &ThreadId) -> bool

impl PartialEq<SystemTime> for SystemTime

pub fn eq(&self, other: &SystemTime) -> bool

pub fn ne(&self, other: &SystemTime) -> bool

impl PartialEq<AccessFlags> for AccessFlags

pub fn eq(&self, other: &AccessFlags) -> bool

pub fn ne(&self, other: &AccessFlags) -> bool

impl PartialEq<Gid> for Gid

pub fn eq(&self, other: &Gid) -> bool

pub fn ne(&self, other: &Gid) -> bool

impl PartialEq<Group> for otter_api_tests::unistd::Group

pub fn eq(&self, other: &Group) -> bool

pub fn ne(&self, other: &Group) -> bool

impl PartialEq<Pid> for Pid

pub fn eq(&self, other: &Pid) -> bool

pub fn ne(&self, other: &Pid) -> bool

impl PartialEq<User> for User

pub fn eq(&self, other: &User) -> bool

pub fn ne(&self, other: &User) -> bool

impl PartialEq<UCred> for UCred

pub fn eq(&self, other: &UCred) -> bool

pub fn ne(&self, other: &UCred) -> bool

impl PartialEq<LimbVal> for LimbVal

pub fn eq(&self, other: &LimbVal) -> bool

pub fn ne(&self, other: &LimbVal) -> bool

impl PartialEq<Overflow> for Overflow

pub fn eq(&self, other: &Overflow) -> bool

impl PartialEq<ParseError> for otter_api_tests::zcoord::ParseError

pub fn eq(&self, other: &ParseError) -> bool

impl PartialEq<RangeBackwards> for RangeBackwards

pub fn eq(&self, other: &RangeBackwards) -> bool

impl PartialEq<TotallyUnboundedRange> for TotallyUnboundedRange

pub fn eq(&self, other: &TotallyUnboundedRange) -> bool

impl PartialEq<String> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &String) -> bool

impl<'_, '_, T, U> PartialEq<&'_ [U]> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone, 

pub fn eq(&self, other: &&[U]) -> bool

pub fn ne(&self, other: &&[U]) -> bool

impl<'_, '_, T, U> PartialEq<&'_ mut [U]> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone, 

pub fn eq(&self, other: &&mut [U]) -> bool

pub fn ne(&self, other: &&mut [U]) -> bool

impl<'_, A, B> PartialEq<&'_ [B]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&[B]) -> bool

impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&mut [B]) -> bool

impl<'_, A, B, const N: usize> PartialEq<&'_ [B; N]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&[B; N]) -> bool

impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &&mut [B; N]) -> bool

impl<'_, T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
    T: PartialEq<U> + Clone,
    A: Allocator, 

pub fn eq(&self, other: &Vec<U, A>) -> bool

pub fn ne(&self, other: &Vec<U, A>) -> bool

impl<'a> PartialEq<&'a str> for otter_api_tests::serde_json::Value

pub fn eq(&self, other: &&str) -> bool

impl<'a> PartialEq<Item<'a>> for Item<'a>

pub fn eq(&self, other: &Item<'a>) -> bool

pub fn ne(&self, other: &Item<'a>) -> bool

impl<'a> PartialEq<FcntlArg<'a>> for FcntlArg<'a>

pub fn eq(&self, other: &FcntlArg<'a>) -> bool

pub fn ne(&self, other: &FcntlArg<'a>) -> bool

impl<'a> PartialEq<ControlMessage<'a>> for ControlMessage<'a>

pub fn eq(&self, other: &ControlMessage<'a>) -> bool

pub fn ne(&self, other: &ControlMessage<'a>) -> bool

impl<'a> PartialEq<Unexpected<'a>> for Unexpected<'a>

pub fn eq(&self, other: &Unexpected<'a>) -> bool

pub fn ne(&self, other: &Unexpected<'a>) -> bool

impl<'a> PartialEq<AddrName<'a>> for AddrName<'a>

pub fn eq(&self, other: &AddrName<'a>) -> bool

pub fn ne(&self, other: &AddrName<'a>) -> bool

impl<'a> PartialEq<bool> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &bool) -> bool

impl<'a> PartialEq<bool> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &bool) -> bool

impl<'a> PartialEq<f32> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f32) -> bool

impl<'a> PartialEq<f32> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f32) -> bool

impl<'a> PartialEq<f64> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f64) -> bool

impl<'a> PartialEq<f64> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &f64) -> bool

impl<'a> PartialEq<i8> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i8) -> bool

impl<'a> PartialEq<i8> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i8) -> bool

impl<'a> PartialEq<i16> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i16) -> bool

impl<'a> PartialEq<i16> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i16) -> bool

impl<'a> PartialEq<i32> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i32) -> bool

impl<'a> PartialEq<i32> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i32) -> bool

impl<'a> PartialEq<i64> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i64) -> bool

impl<'a> PartialEq<i64> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &i64) -> bool

impl<'a> PartialEq<isize> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &isize) -> bool

impl<'a> PartialEq<isize> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &isize) -> bool

impl<'a> PartialEq<u8> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u8) -> bool

impl<'a> PartialEq<u8> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u8) -> bool

impl<'a> PartialEq<u16> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u16) -> bool

impl<'a> PartialEq<u16> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u16) -> bool

impl<'a> PartialEq<u32> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u32) -> bool

impl<'a> PartialEq<u32> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u32) -> bool

impl<'a> PartialEq<u64> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u64) -> bool

impl<'a> PartialEq<u64> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &u64) -> bool

impl<'a> PartialEq<usize> for &'a otter_api_tests::serde_json::Value

pub fn eq(&self, other: &usize) -> bool

impl<'a> PartialEq<usize> for &'a mut otter_api_tests::serde_json::Value

pub fn eq(&self, other: &usize) -> bool

impl<'a> PartialEq<Location<'a>> for otter_api_tests::imports::failure::_core::panic::Location<'a>

pub fn eq(&self, other: &Location<'a>) -> bool

pub fn ne(&self, other: &Location<'a>) -> 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

impl<'a> PartialEq<Metadata<'a>> for Metadata<'a>

pub fn eq(&self, other: &Metadata<'a>) -> bool

pub fn ne(&self, other: &Metadata<'a>) -> bool

impl<'a> PartialEq<MetadataBuilder<'a>> for MetadataBuilder<'a>

pub fn eq(&self, other: &MetadataBuilder<'a>) -> bool

pub fn ne(&self, other: &MetadataBuilder<'a>) -> bool

impl<'a> PartialEq<CmsgIterator<'a>> for CmsgIterator<'a>

pub fn eq(&self, other: &CmsgIterator<'a>) -> bool

pub fn ne(&self, other: &CmsgIterator<'a>) -> bool

impl<'a> PartialEq<RecvMsg<'a>> for RecvMsg<'a>

pub fn eq(&self, other: &RecvMsg<'a>) -> bool

pub fn ne(&self, other: &RecvMsg<'a>) -> bool

impl<'a> PartialEq<RawRef<'a>> for RawRef<'a>

pub fn eq(&self, other: &RawRef<'a>) -> bool

pub fn ne(&self, other: &RawRef<'a>) -> bool

impl<'a, 'b> PartialEq<&'a OsStr> for PathBuf

pub fn eq(&self, other: &&'a OsStr) -> bool

impl<'a, 'b> PartialEq<&'a Path> for Cow<'b, OsStr>

pub fn eq(&self, other: &&'a Path) -> bool

impl<'a, 'b> PartialEq<&'a Path> for OsStr

pub fn eq(&self, other: &&'a Path) -> bool

impl<'a, 'b> PartialEq<&'a Path> for PathBuf

pub fn eq(&self, other: &&'a Path) -> bool

impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

pub fn eq(&self, other: &&'b str) -> bool

pub fn ne(&self, other: &&'b str) -> bool

impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, OsStr>

pub fn eq(&self, other: &&'b OsStr) -> bool

impl<'a, 'b> PartialEq<&'b OsStr> for Cow<'a, Path>

pub fn eq(&self, other: &&'b OsStr) -> bool

impl<'a, 'b> PartialEq<&'b Path> for Cow<'a, Path>

pub fn eq(&self, other: &&'b Path) -> bool

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for &'b OsStr

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for OsStr

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, OsStr>> for PathBuf

pub fn eq(&self, other: &Cow<'a, OsStr>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, Path>> for &'b OsStr

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, Path>> for OsStr

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl<'a, 'b> PartialEq<Cow<'a, Path>> for PathBuf

pub fn eq(&self, other: &Cow<'a, Path>) -> bool

impl<'a, 'b> PartialEq<str> for Cow<'a, str>

pub fn eq(&self, other: &str) -> bool

pub fn ne(&self, other: &str) -> bool

impl<'a, 'b> PartialEq<OsStr> for Cow<'a, OsStr>

pub fn eq(&self, other: &OsStr) -> bool

impl<'a, 'b> PartialEq<OsStr> for Cow<'a, Path>

pub fn eq(&self, other: &OsStr) -> bool

impl<'a, 'b> PartialEq<OsStr> for PathBuf

pub fn eq(&self, other: &OsStr) -> bool

impl<'a, 'b> PartialEq<PathBuf> for &'a OsStr

pub fn eq(&self, other: &PathBuf) -> bool

impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, OsStr>

pub fn eq(&self, other: &PathBuf) -> bool

impl<'a, 'b> PartialEq<PathBuf> for Cow<'a, Path>

pub fn eq(&self, other: &PathBuf) -> bool

impl<'a, 'b> PartialEq<PathBuf> for OsStr

pub fn eq(&self, other: &PathBuf) -> bool

impl<'a, 'b> PartialEq<String> for Cow<'a, str>

pub fn eq(&self, other: &String) -> bool

pub fn ne(&self, other: &String) -> bool

impl<'a, 'b> PartialEq<OsString> for &'a OsStr

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<OsString> for Cow<'a, OsStr>

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<OsString> for Cow<'a, Path>

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<OsString> for OsStr

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<OsString> for PathBuf

pub fn eq(&self, other: &OsString) -> bool

impl<'a, 'b> PartialEq<Path> for &'a OsStr

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b> PartialEq<Path> for Cow<'a, OsStr>

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b> PartialEq<Path> for Cow<'a, Path>

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b> PartialEq<Path> for OsStr

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b> PartialEq<Path> for PathBuf

pub fn eq(&self, other: &Path) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 0]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 0]) -> bool

pub fn ne(&self, other: &&'b [B; 0]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 0]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 0]) -> bool

pub fn ne(&self, other: &&'b [B; 0]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 1]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 1]) -> bool

pub fn ne(&self, other: &&'b [B; 1]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 1]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 1]) -> bool

pub fn ne(&self, other: &&'b [B; 1]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 2]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 2]) -> bool

pub fn ne(&self, other: &&'b [B; 2]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 2]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 2]) -> bool

pub fn ne(&self, other: &&'b [B; 2]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 3]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 3]) -> bool

pub fn ne(&self, other: &&'b [B; 3]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 3]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 3]) -> bool

pub fn ne(&self, other: &&'b [B; 3]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 4]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 4]) -> bool

pub fn ne(&self, other: &&'b [B; 4]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 4]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 4]) -> bool

pub fn ne(&self, other: &&'b [B; 4]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 5]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 5]) -> bool

pub fn ne(&self, other: &&'b [B; 5]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 5]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 5]) -> bool

pub fn ne(&self, other: &&'b [B; 5]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 6]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 6]) -> bool

pub fn ne(&self, other: &&'b [B; 6]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 6]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 6]) -> bool

pub fn ne(&self, other: &&'b [B; 6]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 7]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 7]) -> bool

pub fn ne(&self, other: &&'b [B; 7]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 7]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 7]) -> bool

pub fn ne(&self, other: &&'b [B; 7]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 8]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 8]) -> bool

pub fn ne(&self, other: &&'b [B; 8]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 8]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 8]) -> bool

pub fn ne(&self, other: &&'b [B; 8]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 9]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 9]) -> bool

pub fn ne(&self, other: &&'b [B; 9]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 9]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 9]) -> bool

pub fn ne(&self, other: &&'b [B; 9]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 10]) -> bool

pub fn ne(&self, other: &&'b [B; 10]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 10]) -> bool

pub fn ne(&self, other: &&'b [B; 10]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 11]) -> bool

pub fn ne(&self, other: &&'b [B; 11]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 11]) -> bool

pub fn ne(&self, other: &&'b [B; 11]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 12]) -> bool

pub fn ne(&self, other: &&'b [B; 12]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 12]) -> bool

pub fn ne(&self, other: &&'b [B; 12]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 13]) -> bool

pub fn ne(&self, other: &&'b [B; 13]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 13]) -> bool

pub fn ne(&self, other: &&'b [B; 13]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 14]) -> bool

pub fn ne(&self, other: &&'b [B; 14]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 14]) -> bool

pub fn ne(&self, other: &&'b [B; 14]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 15]) -> bool

pub fn ne(&self, other: &&'b [B; 15]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 15]) -> bool

pub fn ne(&self, other: &&'b [B; 15]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 16]) -> bool

pub fn ne(&self, other: &&'b [B; 16]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 16]) -> bool

pub fn ne(&self, other: &&'b [B; 16]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 17]) -> bool

pub fn ne(&self, other: &&'b [B; 17]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 17]) -> bool

pub fn ne(&self, other: &&'b [B; 17]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 18]) -> bool

pub fn ne(&self, other: &&'b [B; 18]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 18]) -> bool

pub fn ne(&self, other: &&'b [B; 18]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 19]) -> bool

pub fn ne(&self, other: &&'b [B; 19]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 19]) -> bool

pub fn ne(&self, other: &&'b [B; 19]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 20]) -> bool

pub fn ne(&self, other: &&'b [B; 20]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 20]) -> bool

pub fn ne(&self, other: &&'b [B; 20]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 21]) -> bool

pub fn ne(&self, other: &&'b [B; 21]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 21]) -> bool

pub fn ne(&self, other: &&'b [B; 21]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 22]) -> bool

pub fn ne(&self, other: &&'b [B; 22]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 22]) -> bool

pub fn ne(&self, other: &&'b [B; 22]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 23]) -> bool

pub fn ne(&self, other: &&'b [B; 23]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 23]) -> bool

pub fn ne(&self, other: &&'b [B; 23]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 24]) -> bool

pub fn ne(&self, other: &&'b [B; 24]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 24]) -> bool

pub fn ne(&self, other: &&'b [B; 24]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 25]) -> bool

pub fn ne(&self, other: &&'b [B; 25]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 25]) -> bool

pub fn ne(&self, other: &&'b [B; 25]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 26]) -> bool

pub fn ne(&self, other: &&'b [B; 26]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 26]) -> bool

pub fn ne(&self, other: &&'b [B; 26]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 27]) -> bool

pub fn ne(&self, other: &&'b [B; 27]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 27]) -> bool

pub fn ne(&self, other: &&'b [B; 27]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 28]) -> bool

pub fn ne(&self, other: &&'b [B; 28]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 28]) -> bool

pub fn ne(&self, other: &&'b [B; 28]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 29]) -> bool

pub fn ne(&self, other: &&'b [B; 29]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 29]) -> bool

pub fn ne(&self, other: &&'b [B; 29]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 30]) -> bool

pub fn ne(&self, other: &&'b [B; 30]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 30]) -> bool

pub fn ne(&self, other: &&'b [B; 30]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 31]) -> bool

pub fn ne(&self, other: &&'b [B; 31]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 31]) -> bool

pub fn ne(&self, other: &&'b [B; 31]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 32]) -> bool

pub fn ne(&self, other: &&'b [B; 32]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B; 32]) -> bool

pub fn ne(&self, other: &&'b [B; 32]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 0]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 0]) -> bool

pub fn ne(&self, other: &[B; 0]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 0]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 0]) -> bool

pub fn ne(&self, other: &[B; 0]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 1]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 1]) -> bool

pub fn ne(&self, other: &[B; 1]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 1]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 1]) -> bool

pub fn ne(&self, other: &[B; 1]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 2]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 2]) -> bool

pub fn ne(&self, other: &[B; 2]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 2]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 2]) -> bool

pub fn ne(&self, other: &[B; 2]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 3]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 3]) -> bool

pub fn ne(&self, other: &[B; 3]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 3]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 3]) -> bool

pub fn ne(&self, other: &[B; 3]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 4]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 4]) -> bool

pub fn ne(&self, other: &[B; 4]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 4]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 4]) -> bool

pub fn ne(&self, other: &[B; 4]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 5]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 5]) -> bool

pub fn ne(&self, other: &[B; 5]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 5]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 5]) -> bool

pub fn ne(&self, other: &[B; 5]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 6]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 6]) -> bool

pub fn ne(&self, other: &[B; 6]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 6]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 6]) -> bool

pub fn ne(&self, other: &[B; 6]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 7]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 7]) -> bool

pub fn ne(&self, other: &[B; 7]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 7]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 7]) -> bool

pub fn ne(&self, other: &[B; 7]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 8]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 8]) -> bool

pub fn ne(&self, other: &[B; 8]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 8]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 8]) -> bool

pub fn ne(&self, other: &[B; 8]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 9]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 9]) -> bool

pub fn ne(&self, other: &[B; 9]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 9]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 9]) -> bool

pub fn ne(&self, other: &[B; 9]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 10]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 10]) -> bool

pub fn ne(&self, other: &[B; 10]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 10]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 10]) -> bool

pub fn ne(&self, other: &[B; 10]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 11]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 11]) -> bool

pub fn ne(&self, other: &[B; 11]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 11]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 11]) -> bool

pub fn ne(&self, other: &[B; 11]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 12]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 12]) -> bool

pub fn ne(&self, other: &[B; 12]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 12]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 12]) -> bool

pub fn ne(&self, other: &[B; 12]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 13]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 13]) -> bool

pub fn ne(&self, other: &[B; 13]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 13]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 13]) -> bool

pub fn ne(&self, other: &[B; 13]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 14]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 14]) -> bool

pub fn ne(&self, other: &[B; 14]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 14]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 14]) -> bool

pub fn ne(&self, other: &[B; 14]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 15]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 15]) -> bool

pub fn ne(&self, other: &[B; 15]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 15]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 15]) -> bool

pub fn ne(&self, other: &[B; 15]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 16]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 16]) -> bool

pub fn ne(&self, other: &[B; 16]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 16]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 16]) -> bool

pub fn ne(&self, other: &[B; 16]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 17]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 17]) -> bool

pub fn ne(&self, other: &[B; 17]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 17]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 17]) -> bool

pub fn ne(&self, other: &[B; 17]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 18]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 18]) -> bool

pub fn ne(&self, other: &[B; 18]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 18]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 18]) -> bool

pub fn ne(&self, other: &[B; 18]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 19]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 19]) -> bool

pub fn ne(&self, other: &[B; 19]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 19]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 19]) -> bool

pub fn ne(&self, other: &[B; 19]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 20]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 20]) -> bool

pub fn ne(&self, other: &[B; 20]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 20]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 20]) -> bool

pub fn ne(&self, other: &[B; 20]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 21]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 21]) -> bool

pub fn ne(&self, other: &[B; 21]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 21]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 21]) -> bool

pub fn ne(&self, other: &[B; 21]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 22]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 22]) -> bool

pub fn ne(&self, other: &[B; 22]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 22]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 22]) -> bool

pub fn ne(&self, other: &[B; 22]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 23]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 23]) -> bool

pub fn ne(&self, other: &[B; 23]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 23]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 23]) -> bool

pub fn ne(&self, other: &[B; 23]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 24]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 24]) -> bool

pub fn ne(&self, other: &[B; 24]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 24]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 24]) -> bool

pub fn ne(&self, other: &[B; 24]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 25]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 25]) -> bool

pub fn ne(&self, other: &[B; 25]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 25]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 25]) -> bool

pub fn ne(&self, other: &[B; 25]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 26]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 26]) -> bool

pub fn ne(&self, other: &[B; 26]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 26]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 26]) -> bool

pub fn ne(&self, other: &[B; 26]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 27]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 27]) -> bool

pub fn ne(&self, other: &[B; 27]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 27]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 27]) -> bool

pub fn ne(&self, other: &[B; 27]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 28]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 28]) -> bool

pub fn ne(&self, other: &[B; 28]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 28]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 28]) -> bool

pub fn ne(&self, other: &[B; 28]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 29]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 29]) -> bool

pub fn ne(&self, other: &[B; 29]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 29]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 29]) -> bool

pub fn ne(&self, other: &[B; 29]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 30]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 30]) -> bool

pub fn ne(&self, other: &[B; 30]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 30]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 30]) -> bool

pub fn ne(&self, other: &[B; 30]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 31]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 31]) -> bool

pub fn ne(&self, other: &[B; 31]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 31]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 31]) -> bool

pub fn ne(&self, other: &[B; 31]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 32]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 32]) -> bool

pub fn ne(&self, other: &[B; 32]) -> bool

impl<'a, 'b, A, B, I> PartialEq<[B; 32]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B; 32]) -> bool

pub fn ne(&self, other: &[B; 32]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B]) -> bool

pub fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b [B]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b [B]) -> bool

pub fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b mut [B]) -> bool

pub fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &&'b mut [B]) -> bool

pub fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &Vec<B, Global>) -> bool

pub fn ne(&self, other: &Vec<B, Global>) -> bool

impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a mut IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &Vec<B, Global>) -> bool

pub fn ne(&self, other: &Vec<B, Global>) -> bool

impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &Vec<B, Global>) -> bool

pub fn ne(&self, other: &Vec<B, Global>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &&'a IndexSlice<J, [B]>) -> bool

pub fn ne(&self, other: &&'a IndexSlice<J, [B]>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool

pub fn ne(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<&'b IndexSlice<J, [B]>> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &&'b IndexSlice<J, [B]>) -> bool

pub fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<&'b mut IndexSlice<J, [B]>> for otter_api_tests::shapelib::IndexVec<I, A> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool

pub fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &IndexVec<J, B>) -> bool

pub fn ne(&self, other: &IndexVec<J, B>) -> bool

impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx,
    J: Idx, 

pub fn eq(&self, other: &IndexVec<J, B>) -> bool

pub fn ne(&self, other: &IndexVec<J, B>) -> bool

impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B> where
    C: ToOwned + ?Sized,
    B: PartialEq<C> + ToOwned + ?Sized, 

pub fn eq(&self, other: &Cow<'b, C>) -> bool

impl<'b, 'c, T> PartialEq<Reference<'b, 'c, T>> for Reference<'b, 'c, T> where
    T: 'static + PartialEq<T> + ?Sized, 

pub fn eq(&self, other: &Reference<'b, 'c, T>) -> bool

pub fn ne(&self, other: &Reference<'b, 'c, T>) -> bool

impl<'d> PartialEq<Iter<'d>> for Iter<'d>

pub fn eq(&self, other: &Iter<'d>) -> bool

pub fn ne(&self, other: &Iter<'d>) -> bool

impl<'t> PartialEq<Match<'t>> for otter_api_tests::imports::regex::bytes::Match<'t>

pub fn eq(&self, other: &Match<'t>) -> bool

pub fn ne(&self, other: &Match<'t>) -> bool

impl<'t> PartialEq<Match<'t>> for otter_api_tests::imports::regex::Match<'t>

pub fn eq(&self, other: &Match<'t>) -> bool

pub fn ne(&self, other: &Match<'t>) -> bool

impl<A> PartialEq<[<A as Array>::Item]> for otter_api_tests::shapelib::ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

pub fn eq(&self, other: &[<A as Array>::Item]) -> bool

impl<A> PartialEq<str> for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn eq(&self, rhs: &str) -> bool

impl<A> PartialEq<ArrayString<A>> for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn eq(&self, rhs: &ArrayString<A>) -> bool

impl<A> PartialEq<ArrayVec<A>> for otter_api_tests::shapelib::ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

pub fn eq(&self, other: &ArrayVec<A>) -> bool

impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
    A: PartialEq<A>, 

pub fn eq(&self, other: &VecDeque<A>) -> bool

impl<A, B> PartialEq<EitherOrBoth<A, B>> for EitherOrBoth<A, B> where
    B: PartialEq<B>,
    A: PartialEq<A>, 

pub fn eq(&self, other: &EitherOrBoth<A, B>) -> bool

pub fn ne(&self, other: &EitherOrBoth<A, B>) -> bool

impl<A, B> PartialEq<Vec<B, Global>> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &Vec<B, Global>) -> bool

impl<A, B, const N: usize> PartialEq<[B; N]> for VecDeque<A> where
    A: PartialEq<B>, 

pub fn eq(&self, other: &[B; N]) -> bool

impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
    C: PartialEq<C>,
    B: PartialEq<B>, 

pub fn eq(&self, other: &ControlFlow<B, C>) -> bool

pub fn ne(&self, other: &ControlFlow<B, C>) -> bool

impl<D> PartialEq<OccultationKindGeneral<D>> for OccultationKindGeneral<D> where
    D: PartialEq<D>, 

pub fn eq(&self, other: &OccultationKindGeneral<D>) -> bool

pub fn ne(&self, other: &OccultationKindGeneral<D>) -> bool

impl<Dyn> PartialEq<DynMetadata<Dyn>> for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn eq(&self, other: &DynMetadata<Dyn>) -> bool

impl<E> PartialEq<ParseNotNanError<E>> for ParseNotNanError<E> where
    E: PartialEq<E>, 

pub fn eq(&self, other: &ParseNotNanError<E>) -> bool

pub fn ne(&self, other: &ParseNotNanError<E>) -> bool

impl<E> PartialEq<Compat<E>> for Compat<E> where
    E: PartialEq<E>, 

pub fn eq(&self, other: &Compat<E>) -> bool

pub fn ne(&self, other: &Compat<E>) -> bool

impl<H> PartialEq<BuildHasherDefault<H>> for BuildHasherDefault<H>

pub fn eq(&self, _other: &BuildHasherDefault<H>) -> bool

impl<I, A, B> PartialEq<[B]> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &[B]) -> bool

pub fn ne(&self, other: &[B]) -> bool

impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
    A: PartialEq<B>,
    I: Idx, 

pub fn eq(&self, other: &IndexSlice<I, [B]>) -> bool

pub fn ne(&self, other: &IndexSlice<I, [B]>) -> bool

impl<I, T> PartialEq<IndexVec<I, T>> for otter_api_tests::shapelib::IndexVec<I, T> where
    T: PartialEq<T>,
    I: PartialEq<I> + Idx, 

pub fn eq(&self, other: &IndexVec<I, T>) -> bool

pub fn ne(&self, other: &IndexVec<I, T>) -> bool

impl<Idx> PartialEq<Range<Idx>> for otter_api_tests::imports::failure::_core::ops::Range<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &Range<Idx>) -> bool

pub fn ne(&self, other: &Range<Idx>) -> bool

impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeFrom<Idx>) -> bool

pub fn ne(&self, other: &RangeFrom<Idx>) -> bool

impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeInclusive<Idx>) -> bool

pub fn ne(&self, other: &RangeInclusive<Idx>) -> bool

impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeTo<Idx>) -> bool

pub fn ne(&self, other: &RangeTo<Idx>) -> bool

impl<Idx> PartialEq<RangeToInclusive<Idx>> for RangeToInclusive<Idx> where
    Idx: PartialEq<Idx>, 

pub fn eq(&self, other: &RangeToInclusive<Idx>) -> bool

pub fn ne(&self, other: &RangeToInclusive<Idx>) -> bool

impl<K, V> PartialEq<SecondaryMap<K, V>> for SecondaryMap<K, V> where
    K: Key,
    V: PartialEq<V>, 

pub fn eq(&self, other: &SecondaryMap<K, V>) -> bool

impl<K, V> PartialEq<BTreeMap<K, V>> for BTreeMap<K, V> where
    K: PartialEq<K>,
    V: PartialEq<V>, 

pub fn eq(&self, other: &BTreeMap<K, V>) -> bool

impl<K, V> PartialEq<EnumMap<K, V>> for EnumMap<K, V> where
    K: Enum<V>,
    V: PartialEq<V>, 

pub fn eq(&self, other: &EnumMap<K, V>) -> bool

impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
    S: BuildHasher,
    K: Eq + Hash,
    V: PartialEq<V>, 

pub fn eq(&self, other: &HashMap<K, V, S>) -> bool

impl<K, V, S> PartialEq<SparseSecondaryMap<K, V, S>> for SparseSecondaryMap<K, V, S> where
    S: BuildHasher,
    K: Key,
    V: PartialEq<V>, 

pub fn eq(&self, other: &SparseSecondaryMap<K, V, S>) -> bool

impl<L, R> PartialEq<Either<L, R>> for Either<L, R> where
    L: PartialEq<L>,
    R: PartialEq<R>, 

pub fn eq(&self, other: &Either<L, R>) -> bool

pub fn ne(&self, other: &Either<L, R>) -> bool

impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
    P: Deref,
    Q: Deref,
    <P as Deref>::Target: PartialEq<<Q as Deref>::Target>, 

pub fn eq(&self, other: &Pin<Q>) -> bool

pub fn ne(&self, other: &Pin<Q>) -> bool

impl<T> PartialEq<RegionC<T>> for RegionC<T> where
    T: PartialEq<T> + Copy, 

pub fn eq(&self, other: &RegionC<T>) -> bool

pub fn ne(&self, other: &RegionC<T>) -> bool

impl<T> PartialEq<LocalResult<T>> for LocalResult<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &LocalResult<T>) -> bool

pub fn ne(&self, other: &LocalResult<T>) -> bool

impl<T> PartialEq<Bound<T>> for Bound<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Bound<T>) -> bool

pub fn ne(&self, other: &Bound<T>) -> bool

impl<T> PartialEq<Option<T>> for Option<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Option<T>) -> bool

pub fn ne(&self, other: &Option<T>) -> bool

impl<T> PartialEq<Poll<T>> for Poll<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Poll<T>) -> bool

pub fn ne(&self, other: &Poll<T>) -> bool

impl<T> PartialEq<FoldWhile<T>> for FoldWhile<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &FoldWhile<T>) -> bool

pub fn ne(&self, other: &FoldWhile<T>) -> bool

impl<T> PartialEq<MinMaxResult<T>> for MinMaxResult<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &MinMaxResult<T>) -> bool

pub fn ne(&self, other: &MinMaxResult<T>) -> bool

impl<T> PartialEq<Position<T>> for otter_api_tests::imports::otter_base::imports::itertools::Position<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Position<T>) -> bool

pub fn ne(&self, other: &Position<T>) -> bool

impl<T> PartialEq<TrySendError<T>> for TrySendError<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &TrySendError<T>) -> bool

pub fn ne(&self, other: &TrySendError<T>) -> bool

impl<T> PartialEq<Cell<T>> for Cell<T> where
    T: PartialEq<T> + Copy, 

pub fn eq(&self, other: &Cell<T>) -> bool

impl<T> PartialEq<OnceCell<T>> for otter_api_tests::imports::failure::_core::lazy::OnceCell<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &OnceCell<T>) -> bool

impl<T> PartialEq<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

pub fn eq(&self, other: &NonNull<T>) -> bool

impl<T> PartialEq<IoVec<T>> for IoVec<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &IoVec<T>) -> bool

pub fn ne(&self, other: &IoVec<T>) -> bool

impl<T> PartialEq<OnceCell<T>> for otter_api_tests::imports::once_cell::sync::OnceCell<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &OnceCell<T>) -> bool

impl<T> PartialEq<OnceCell<T>> for otter_api_tests::imports::once_cell::unsync::OnceCell<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &OnceCell<T>) -> bool

impl<T> PartialEq<NotNan<T>> for NotNan<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &NotNan<T>) -> bool

pub fn ne(&self, other: &NotNan<T>) -> bool

impl<T> PartialEq<CapacityError<T>> for CapacityError<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &CapacityError<T>) -> bool

pub fn ne(&self, other: &CapacityError<T>) -> bool

impl<T> PartialEq<Spanned<T>> for Spanned<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Spanned<T>) -> bool

impl<T> PartialEq<Cursor<T>> for Cursor<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Cursor<T>) -> bool

pub fn ne(&self, other: &Cursor<T>) -> bool

impl<T> PartialEq<SendError<T>> for SendError<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &SendError<T>) -> bool

pub fn ne(&self, other: &SendError<T>) -> bool

impl<T> PartialEq<Discriminant<T>> for Discriminant<T>

pub fn eq(&self, rhs: &Discriminant<T>) -> bool

impl<T> PartialEq<ManuallyDrop<T>> for ManuallyDrop<T> where
    T: PartialEq<T> + ?Sized, 

pub fn eq(&self, other: &ManuallyDrop<T>) -> bool

pub fn ne(&self, other: &ManuallyDrop<T>) -> bool

impl<T> PartialEq<Arc<T>> for Arc<T> where
    T: PartialEq<T> + ?Sized, 

pub fn eq(&self, other: &Arc<T>) -> bool

Equality for two Arcs.

Two Arcs are equal if their inner values are equal, even if they are stored in different allocation.

If T also implements Eq (implying reflexivity of equality), two Arcs that point to the same allocation are always equal.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five == Arc::new(5));

pub fn ne(&self, other: &Arc<T>) -> bool

Inequality for two Arcs.

Two Arcs are unequal if their inner values are unequal.

If T also implements Eq (implying reflexivity of equality), two Arcs that point to the same value are never unequal.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five != Arc::new(6));

impl<T> PartialEq<BTreeSet<T>> for BTreeSet<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &BTreeSet<T>) -> bool

pub fn ne(&self, other: &BTreeSet<T>) -> bool

impl<T> PartialEq<OrderedFloat<T>> for OrderedFloat<T> where
    T: Float, 

pub fn eq(&self, other: &OrderedFloat<T>) -> bool

impl<T> PartialEq<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

pub fn eq(&self, _other: &PhantomData<T>) -> bool

impl<T> PartialEq<PosC<T>> for PosC<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &PosC<T>) -> bool

pub fn ne(&self, other: &PosC<T>) -> bool

impl<T> PartialEq<RectC<T>> for RectC<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &RectC<T>) -> bool

pub fn ne(&self, other: &RectC<T>) -> bool

impl<T> PartialEq<Wrapping<T>> for Wrapping<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Wrapping<T>) -> bool

pub fn ne(&self, other: &Wrapping<T>) -> bool

impl<T> PartialEq<IsHtmlFormatted<T>> for IsHtmlFormatted<T> where
    T: PartialEq<T> + Display, 

pub fn eq(&self, other: &IsHtmlFormatted<T>) -> bool

pub fn ne(&self, other: &IsHtmlFormatted<T>) -> bool

impl<T> PartialEq<OldNew<T>> for OldNew<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &OldNew<T>) -> bool

pub fn ne(&self, other: &OldNew<T>) -> bool

impl<T> PartialEq<RefCell<T>> for RefCell<T> where
    T: PartialEq<T> + ?Sized, 

pub fn eq(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

impl<T> PartialEq<Reverse<T>> for Reverse<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Reverse<T>) -> bool

pub fn ne(&self, other: &Reverse<T>) -> bool

impl<T> PartialEq<T> for Void

pub fn eq(&self, &T) -> bool

impl<T> PartialEq<T> for NotNan<T> where
    T: Float, 

pub fn eq(&self, other: &T) -> bool

impl<T> PartialEq<T> for OrderedFloat<T> where
    T: Float, 

pub fn eq(&self, other: &T) -> bool

impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where
    T: PartialEq<T>,
    E: PartialEq<E>, 

pub fn eq(&self, other: &Result<T, E>) -> bool

pub fn ne(&self, other: &Result<T, E>) -> bool

impl<T, S> PartialEq<HashSet<T, S>> for HashSet<T, S> where
    S: BuildHasher,
    T: Eq + Hash, 

pub fn eq(&self, other: &HashSet<T, S>) -> bool

impl<Tz, Tz2> PartialEq<Date<Tz2>> for Date<Tz> where
    Tz: TimeZone,
    Tz2: TimeZone, 

pub fn eq(&self, other: &Date<Tz2>) -> bool

impl<Tz, Tz2> PartialEq<DateTime<Tz2>> for DateTime<Tz> where
    Tz: TimeZone,
    Tz2: TimeZone, 

pub fn eq(&self, other: &DateTime<Tz2>) -> bool

impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialEq<R>,
    Y: PartialEq<Y>, 

pub fn eq(&self, other: &GeneratorState<Y, R>) -> bool

pub fn ne(&self, other: &GeneratorState<Y, R>) -> bool

Loading content...