Trait enso_prelude::Hash

pub trait Hash {
    fn hash<H>(&self, state: &mut H)
    where
        H: Hasher;

    fn hash_slice<H>(data: &[Self], state: &mut H)
    where
        H: Hasher,
    { ... }
}

A hashable type.

Types implementing Hash are able to be hashed with an instance of Hasher.

Implementing Hash

You can derive Hash with #[derive(Hash)] if all fields implement Hash. The resulting hash will be the combination of the values from calling hash on each field.

#[derive(Hash)]
struct Rustacean {
    name: String,
    country: String,
}

If you need more control over how a value is hashed, you can of course implement the Hash trait yourself:

use std::hash::{Hash, Hasher};

struct Person {
    id: u32,
    name: String,
    phone: u64,
}

impl Hash for Person {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
        self.phone.hash(state);
    }
}

Hash and Eq

When implementing both Hash and Eq, it is important that the following property holds:

k1 == k2 -> hash(k1) == hash(k2)

In other words, if two keys are equal, their hashes must also be equal. HashMap and HashSet both rely on this behavior.

Thankfully, you won’t need to worry about upholding this property when deriving both Eq and Hash with #[derive(PartialEq, Eq, Hash)].

Required methods

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

Examples

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

let mut hasher = DefaultHasher::new();
7920.hash(&mut hasher);
println!("Hash is {:x}!", hasher.finish());

Provided methods

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

This method is meant as a convenience, but its implementation is also explicitly left unspecified. It isn’t guaranteed to be equivalent to repeated calls of hash and implementations of Hash should keep that in mind and call hash themselves if the slice isn’t treated as a whole unit in the PartialEq implementation.

For example, a VecDeque implementation might naïvely call as_slices and then hash_slice on each slice, but this is wrong since the two slices can change with a call to make_contiguous without affecting the PartialEq result. Since these slices aren’t treated as singular units, and instead part of a larger deque, this method cannot be used.

Examples

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

let mut hasher = DefaultHasher::new();
let numbers = [6, 28, 496, 8128];
Hash::hash_slice(&numbers, &mut hasher);
println!("Hash is {:x}!", hasher.finish());

Implementations on Foreign Types

impl<'a> Hash for Component<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SocketAddrV4

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for Ipv4Addr

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for PathBuf

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for Ipv6Addr

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl Hash for Instant

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SocketAddr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for OsString

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for FileType

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Ipv6MulticastScope

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for CStr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Path

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for OsStr

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for IpAddr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for ErrorKind

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SocketAddrV6

pub fn hash<H>(&self, s: &mut H) where
    H: Hasher, 

impl<'_> Hash for PrefixComponent<'_>

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

impl Hash for CString

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SystemTime

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'a> Hash for Prefix<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for UCred

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for ThreadId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for NonZeroI128

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroU64

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Y, R> Hash for GeneratorState<Y, R> where
    R: Hash,
    Y: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Infallible

pub fn hash<H>(&self, &mut H) where
    H: Hasher, 

impl Hash for bool

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for Duration

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<P> Hash for Pin<P> where
    P: Deref,
    <P as Deref>::Target: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for NonZeroI32

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T, const N: usize> Hash for [T; N] where
    T: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for PhantomPinned

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for NonZeroI16

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NoneError

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for ()

pub fn hash<H>(&self, _state: &mut H) where
    H: Hasher, 

impl Hash for u8

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u8], state: &mut H) where
    H: Hasher, 

impl Hash for i64

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i64], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T> Hash for NonNull<T> where
    T: ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'_, T> Hash for &'_ T where
    T: Hash + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for NonZeroIsize

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroU16

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for str

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl Hash for i128

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i128], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T, E> Hash for Result<T, E> where
    T: Hash,
    E: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroI8

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for u32

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u32], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for Ordering

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for i32

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i32], state: &mut H) where
    H: Hasher, 

impl Hash for u64

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u64], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T> Hash for Reverse<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroU8

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for usize

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[usize], state: &mut H) where
    H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'_, T> Hash for &'_ mut T where
    T: Hash + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for Poll<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T> Hash for [T] where
    T: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for NonZeroU128

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for isize

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[isize], state: &mut H) where
    H: Hasher, 

impl<T> Hash for Option<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<'a> Hash for Location<'a>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for u16

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u16], state: &mut H) where
    H: Hasher, 

impl Hash for TypeId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroUsize

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for char

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<T> Hash for Wrapping<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Bound<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for u128

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[u128], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for Ordering

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for i8

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i8], state: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for NonZeroU32

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for NonZeroI64

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Dyn> Hash for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn hash<H>(&self, hasher: &mut H) where
    H: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl Hash for i16

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

pub fn hash_slice<H>(data: &[i16], state: &mut H) where
    H: Hasher, 

impl Hash for !

pub fn hash<H>(&self, &mut H) where
    H: Hasher, 

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

pub fn hash<S>(&self, state: &mut S) where
    S: Hasher, 

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

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn hash<HH>(&self, state: &mut HH) where
    HH: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for String

pub fn hash<H>(&self, hasher: &mut H) where
    H: Hasher, 

impl<T, A> Hash for Vec<T, A> where
    T: Hash,
    A: Allocator, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<A> Hash for VecDeque<A> where
    A: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for BTreeSet<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Arc<T> where
    T: Hash + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for DwLns

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwoId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwDsc

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for EhFrameOffset<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwMacro

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for BigEndian

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwChildren

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwForm

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwLnct

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwTag

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for LittleEndian

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for RunTimeEndian

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwVirtuality

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for UnitSectionOffset<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwDs

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwRle

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for DebugFrameOffset<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwAt

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Register

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for DebugAbbrevOffset<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwLle

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwAddr

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for LineEncoding

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwCfa

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwVis

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Range

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Format

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwUt

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwOrd

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DebugTypeSignature

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwInl

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwAte

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for RangeListsOffset<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwEnd

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwCc

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwLne

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwOp

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwEhPe

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwLang

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwDefaulted

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SectionId

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Encoding

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwIdx

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DwAccess

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for I16Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SectionIndex

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for AddressSize

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for RelocationTarget

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'data> Hash for CompressedData<'data>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for U64Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for LittleEndian

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SymbolSection

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for CompressedFileRange

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for ArchiveKind

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Architecture

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Endianness

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'data> Hash for ObjectMapEntry<'data>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for U32Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for BigEndian

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for I32Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for BinaryFormat

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for U16Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for I64Bytes<E> where
    E: Hash + Endian, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for CompressionFormat

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for SymbolIndex

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'data> Hash for SymbolMapName<'data>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for MZFlush

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TDEFLStatus

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for CompressionLevel

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TINFLStatus

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for CompressionStrategy

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for MZError

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for MZStatus

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for DataFormat

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for StreamResult

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TDEFLFlush

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<E> Hash for Compat<E> where
    E: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<A, B> Hash for EitherOrBoth<A, B> where
    A: Hash,
    B: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<L, R> Hash for Either<L, R> where
    R: Hash,
    L: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for BigUint

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for BigInt

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl Hash for Sign

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Complex<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Ratio<T> where
    T: Clone + Integer + Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T, R, const D: usize> Hash for Isometry<T, R, D> where
    T: Scalar + Hash,
    R: Hash,
    <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for XYZ<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T, const R: usize, const C: usize> Hash for ArrayStorage<T, R, C> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M4x5<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M6x6<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<const R: usize> Hash for Const<R>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T, R, const D: usize> Hash for Similarity<T, R, D> where
    T: Scalar + Hash,
    R: Hash,
    <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for M5x6<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M3x6<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for IJKW<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M4x2<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M5x3<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M3x4<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M6x4<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M6x5<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for XYZW<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M3x2<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M4x4<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for XYZWAB<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M4x3<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M2x4<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for XYZWA<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TAffine

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T, const D: usize> Hash for Point<T, D> where
    T: Scalar + Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for M5x4<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Unit<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M5x5<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M6x2<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TGeneral

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M2x5<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M5x2<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for X<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M6x3<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T, R, C, S> Hash for Matrix<T, R, C, S> where
    C: Dim,
    T: Scalar + Hash,
    R: Dim,
    S: Storage<T, R, C>, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for M4x6<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M3x5<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Quaternion<T> where
    T: Scalar + Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for M2x6<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for XY<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for TProjective

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M2x3<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T, const D: usize> Hash for Rotation<T, D> where
    T: Scalar + Hash,
    <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T, const D: usize> Hash for Translation<T, D> where
    T: Scalar + Hash,
    <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for M2x2<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for M3x3<T> where
    T: Hash + Scalar, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Complex<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Less

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Z0

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<U> Hash for NInt<U> where
    U: Hash + Unsigned + NonZero, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for B1

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<V, A> Hash for TArr<V, A> where
    V: Hash,
    A: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Greater

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<U> Hash for PInt<U> where
    U: Hash + Unsigned + NonZero, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<U, B> Hash for UInt<U, B> where
    U: Hash,
    B: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for ATerm

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for Equal

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for UTerm

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for B0

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for Ratio<T> where
    T: Clone + Integer + Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Implementors

impl Hash for Error

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl Hash for ImString

fn hash<__H: Hasher>(&self, state: &mut __H)

impl Hash for RangeFull

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<'_, B> Hash for Cow<'_, B> where
    B: Hash + ToOwned + ?Sized, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<A> Hash for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<Idx> Hash for enso_prelude::Range<Idx> where
    Idx: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Idx> Hash for RangeFrom<Idx> where
    Idx: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Idx> Hash for RangeInclusive<Idx> where
    Idx: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Idx> Hash for RangeTo<Idx> where
    Idx: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<Idx> Hash for RangeToInclusive<Idx> where
    Idx: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<K, V> Hash for BTreeMap<K, V> where
    K: Hash,
    V: Hash, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for Discriminant<T>

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T> Hash for ManuallyDrop<T> where
    T: Hash + ?Sized, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

impl<T> Hash for PhantomData<T> where
    T: ?Sized, 

pub fn hash<H>(&self, &mut H) where
    H: Hasher, 

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

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

impl<T: Hash> Hash for Switch<T>

fn hash<__H: Hasher>(&self, state: &mut __H)