Trait enso_flexer::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());

Loading content...

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

Loading content...

Implementations on Foreign Types

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 PrefixComponent<'_>

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

impl Hash for Ipv6MulticastScope

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

impl Hash for CString

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

impl Hash for OsStr

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 IpAddr

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 SocketAddr

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 Ipv6Addr

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<'a> Hash for Component<'a>

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 Instant

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

impl Hash for Ipv4Addr

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

impl Hash for SocketAddrV4

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

impl Hash for Path

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

impl Hash for FileType

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 SystemTime

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,
    E: Hash,
    A: Hash,
    F: Hash + ?Sized,
    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 Hash for Ordering

pub fn hash<__H>(&self, state: &mut __H) where
    __H: 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,
    E: Hash,
    A: Hash,
    F: Hash,
    B: Hash,
    G: Hash,
    D: Hash,
    I: Hash,
    H: Hash,
    J: Hash + ?Sized, 

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

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 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,
    E: Hash,
    A: Hash,
    F: Hash,
    B: Hash,
    G: Hash,
    D: 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,
    E: Hash,
    A: Hash,
    F: Hash,
    B: Hash,
    G: Hash,
    D: Hash,
    I: Hash + ?Sized,
    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<T> Hash for Arc<T> where
    T: Hash + ?Sized, 

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> Hash for LinkedList<T> where
    T: Hash, 

pub fn hash<H>(&self, state: &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 State<T>

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

impl Hash for Symbol

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 DwRle

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<T> Hash for LocationListsOffset<T> where
    T: Hash, 

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<R> Hash for LocationListEntry<R> where
    R: Hash + Reader, 

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 Hash for DwInl

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<'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 DwId

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<T> Hash for DebugMacroOffset<T> where
    T: Hash, 

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 DwAddr

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 Hash for DwOrd

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<T> Hash for UnitSectionOffset<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 RunTimeEndian

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<T> Hash for DebugInfoOffset<T> where
    T: Hash, 

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 DwCc

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 DwLang

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 DwForm

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 DwEhPe

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 DwDefaulted

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 Hash for DwVis

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<R> Hash for Expression<R> where
    R: Hash + Reader, 

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 Hash for Register

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 Hash for DwAt

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 Hash for SectionId

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 DebugTypeSignature

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 Hash for Encoding

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 Hash for DwEnd

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 Range

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 DwMacro

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 RelocationTarget

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<E> Hash for U32Bytes<E> where
    E: Hash + Endian, 

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<E> Hash for I16Bytes<E> where
    E: Hash + Endian, 

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 Hash for SymbolIndex

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 Hash for SymbolSection

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<E> Hash for U16Bytes<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 Hash for CompressionFormat

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 BinaryFormat

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<E> Hash for I64Bytes<E> where
    E: Hash + Endian, 

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

impl Hash for Ieee64

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

impl Hash for Ieee32

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 V128

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

impl Hash for FuncType

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

impl Hash for Type

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<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<N> Hash for M6x5<N> where
    N: Hash + Scalar, 

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

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

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

impl Hash for U49

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

impl Hash for U72

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

impl<N, D, R> Hash for Similarity<N, D, R> where
    R: Hash,
    N: Scalar + Hash,
    D: DimName + Hash,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, 

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

impl Hash for U25

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

impl Hash for U101

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

impl Hash for U79

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

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

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

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

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

impl Hash for U86

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

impl Hash for U78

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

impl Hash for U89

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

impl Hash for U74

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

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

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

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

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

impl Hash for U21

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

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

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

impl Hash for U113

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

impl Hash for U99

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

impl Hash for U2

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

impl Hash for U53

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

impl Hash for U118

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

impl Hash for U95

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

impl Hash for U5

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

impl Hash for U110

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

impl Hash for U119

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

impl Hash for U61

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

impl Hash for U96

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

impl Hash for U13

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

impl Hash for U34

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

impl<N, R, C> Hash for ArrayStorage<N, R, C> where
    C: DimName,
    R: DimName,
    N: Hash,
    <R as DimName>::Value: Mul<<C as DimName>::Value>,
    <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>, 

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

impl Hash for U27

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

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

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

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

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

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

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

impl<N> Hash for M3x2<N> where
    N: 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 Hash for U43

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

impl Hash for U35

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

impl<N, D> Hash for Rotation<N, D> where
    N: Scalar + Hash,
    D: DimName + Hash,
    DefaultAllocator: Allocator<N, D, D>,
    <DefaultAllocator as Allocator<N, D, D>>::Buffer: Hash, 

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

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

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

impl Hash for U75

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

impl Hash for U48

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

impl Hash for U14

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

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

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

impl Hash for U116

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

impl Hash for U38

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

impl Hash for U58

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

impl Hash for U1

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

impl Hash for U109

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 Hash for U17

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

impl Hash for U67

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

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

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

impl Hash for U100

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

impl Hash for U31

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

impl Hash for U40

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

impl Hash for U7

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

impl<N, D> Hash for Point<N, D> where
    N: Scalar + Hash,
    D: DimName + Hash,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, 

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

impl Hash for U24

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

impl Hash for U28

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

impl Hash for U57

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

impl Hash for U0

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

impl Hash for U47

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

impl Hash for U37

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

impl Hash for U85

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

impl Hash for U15

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

impl Hash for U23

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

impl<N, D> Hash for Translation<N, D> where
    N: Scalar + Hash,
    D: DimName + Hash,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, 

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

impl Hash for U93

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

impl Hash for U111

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

impl Hash for U4

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

impl Hash for U73

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

impl Hash for U126

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

impl Hash for U124

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

impl<N, D, R> Hash for Isometry<N, D, R> where
    R: Hash,
    N: Scalar + Hash,
    D: DimName + Hash,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, 

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

impl Hash for U44

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

impl Hash for U91

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, 

impl Hash for TAffine

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

impl Hash for U117

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

impl Hash for U107

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

impl Hash for U6

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

impl Hash for U125

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

impl Hash for U52

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

impl Hash for U29

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

impl Hash for U60

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

impl Hash for U65

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, 

impl Hash for U105

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

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

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

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

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

impl Hash for U76

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

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

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

impl Hash for U19

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

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

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

impl Hash for U77

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

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

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

impl Hash for U26

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

impl Hash for U30

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

impl Hash for U55

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

impl Hash for U63

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

impl Hash for U51

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

impl Hash for U104

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

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

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

impl Hash for U82

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

impl Hash for U106

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

impl Hash for U50

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

impl Hash for U22

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

impl Hash for U16

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

impl Hash for U59

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

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

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

impl Hash for U45

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

impl Hash for U97

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

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

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

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

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

impl Hash for U123

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

impl Hash for U56

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

impl Hash for U127

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

impl Hash for U121

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

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

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

impl Hash for U108

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

impl Hash for U20

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

impl Hash for U122

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

impl Hash for U12

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

impl Hash for U88

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

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

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

impl Hash for U94

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

impl Hash for U68

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

impl Hash for U115

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

impl Hash for U103

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 Hash for U80

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

impl Hash for U69

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

impl Hash for U10

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

impl Hash for U87

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

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

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

impl Hash for U70

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

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

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

impl Hash for U84

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

impl Hash for U92

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

impl Hash for U62

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

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

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

impl Hash for U18

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

impl Hash for U3

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

impl Hash for U98

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

impl Hash for U39

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

impl Hash for U42

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

impl Hash for U90

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

impl Hash for U81

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

impl Hash for U41

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

impl<N> Hash for Quaternion<N> where
    N: SimdRealField + Hash, 

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

impl Hash for U9

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

impl Hash for U33

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

impl Hash for U114

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

impl Hash for U112

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

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

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

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

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

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

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

impl Hash for U71

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

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

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

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

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

impl Hash for U83

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

impl Hash for U11

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

impl Hash for U64

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

impl Hash for U66

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

impl Hash for U54

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

impl Hash for U102

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

impl Hash for U36

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

impl Hash for U46

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

impl Hash for U120

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

impl<T, N> Hash for GenericArray<T, N> where
    T: Hash,
    N: ArrayLength<T>, 

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
    A: Hash,
    V: 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
    B: Hash,
    U: 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 Hash for Ident

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

impl Hash for Type

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

impl Hash for Pub

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

impl Hash for Visibility

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

impl Hash for Extern

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

impl Hash for ImplItemType

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

impl Hash for Trait

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

impl Hash for TraitItemType

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

impl Hash for Where

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

impl Hash for PatReference

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

impl Hash for PredicateEq

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

impl Hash for TypeMacro

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

impl Hash for Mut

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

impl Hash for ExprTry

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

impl Hash for Break

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

impl Hash for Le

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

impl Hash for ExprParen

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

impl Hash for Meta

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

impl Hash for Index

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

impl Hash for PatRest

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

impl Hash for LitFloat

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

impl Hash for In

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

impl Hash for LifetimeDef

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

impl Hash for PatStruct

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

impl Hash for Caret

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

impl Hash for Box

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

impl Hash for WherePredicate

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

impl Hash for EqEq

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

impl Hash for Comma

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

impl Hash for Dot3

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

impl Hash for ExprGroup

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

impl Hash for ItemConst

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

impl Hash for ShlEq

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

impl Hash for ItemTraitAlias

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

impl Hash for Attribute

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

impl Hash for GenericMethodArgument

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

impl Hash for As

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

impl Hash for PatBox

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

impl Hash for Path

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

impl Hash for Underscore

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

impl Hash for ExprReference

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

impl Hash for ExprLit

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

impl Hash for LitBool

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

impl Hash for SubEq

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

impl Hash for PathArguments

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

impl Hash for Shl

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

impl Hash for Expr

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

impl Hash for FieldValue

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

impl Hash for AddEq

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

impl Hash for GenericArgument

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

impl Hash for SelfType

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

impl Hash for ItemForeignMod

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

impl Hash for TypeParam

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

impl Hash for AndAnd

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

impl Hash for Return

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

impl Hash for UnOp

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

impl Hash for ForeignItem

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

impl Hash for Item

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

impl Hash for Virtual

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

impl Hash for Do

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

impl Hash for PatType

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

impl Hash for PatWild

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

impl Hash for VisRestricted

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

impl Hash for AttrStyle

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

impl Hash for Override

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

impl Hash for ItemUnion

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

impl Hash for Move

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

impl Hash for Become

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

impl Hash for ExprMethodCall

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

impl Hash for Paren

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

impl Hash for BinOp

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

impl Hash for ExprBinary

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

impl Hash for MacroDelimiter

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

impl Hash for Auto

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

impl Hash for ItemStatic

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

impl Hash for CaretEq

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

impl Hash for RemEq

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

impl Hash for PatMacro

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

impl Hash for FieldsNamed

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

impl Hash for DataEnum

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

impl Hash for Div

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

impl Hash for MetaList

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

impl<'a> Hash for TypeGenerics<'a>

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

impl Hash for Sub

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

impl Hash for ExprMatch

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

impl Hash for AngleBracketedGenericArguments

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

impl Hash for ImplItemConst

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

impl Hash for PathSegment

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

impl Hash for Unsafe

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

impl Hash for Dot2

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

impl Hash for LitByteStr

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

impl Hash for TypeSlice

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

impl Hash for LitInt

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

impl Hash for FatArrow

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

impl Hash for File

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

impl Hash for Loop

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

impl Hash for ExprWhile

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

impl Hash for Typeof

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

impl Hash for UseTree

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

impl Hash for UseName

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

impl Hash for UseGlob

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

impl Hash for Lifetime

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

impl Hash for TraitItemMacro

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

impl Hash for TraitBound

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

impl Hash for FnArg

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

impl Hash for While

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

impl Hash for ItemUse

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

impl Hash for PatIdent

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

impl Hash for Crate

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

impl Hash for For

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

impl<T, P> Hash for Punctuated<T, P> where
    T: Hash,
    P: Hash, 

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

impl Hash for Lit

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

impl Hash for Colon2

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

impl Hash for ExprAssignOp

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

impl Hash for TraitItemMethod

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

impl Hash for UsePath

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

impl Hash for TypeTraitObject

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

impl Hash for Tilde

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

impl Hash for Fields

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

impl Hash for Fn

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

impl Hash for Star

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

impl Hash for ExprReturn

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

impl Hash for Static

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

impl Hash for Local

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

impl Hash for ReturnType

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

impl Hash for Pat

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

impl Hash for Dyn

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

impl Hash for Pound

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

impl Hash for Variant

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

impl Hash for ExprStruct

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

impl Hash for ItemImpl

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

impl Hash for ExprAsync

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

impl Hash for TypeNever

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

impl Hash for Question

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

impl Hash for Binding

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

impl Hash for Brace

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

impl Hash for And

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

impl Hash for TypeGroup

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

impl Hash for NestedMeta

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

impl Hash for RangeLimits

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

impl Hash for Priv

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

impl Hash for ItemEnum

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

impl Hash for OrEq

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

impl Hash for Final

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

impl Hash for Lt

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

impl Hash for ExprIndex

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

impl Hash for AndEq

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

impl Hash for Const

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

impl Hash for ItemTrait

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

impl Hash for LitByte

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

impl Hash for Async

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

impl Hash for ForeignItemStatic

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

impl Hash for ExprAssign

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

impl Hash for SelfValue

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

impl Hash for Mod

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

impl Hash for ItemStruct

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

impl Hash for Use

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

impl Hash for ItemFn

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

impl Hash for ExprLoop

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

impl Hash for OrOr

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

impl Hash for TypeInfer

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

impl Hash for BoundLifetimes

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

impl Hash for PatSlice

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

impl Hash for TraitItemConst

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

impl Hash for ExprTryBlock

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

impl Hash for Gt

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

impl Hash for ExprRepeat

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

impl Hash for Field

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

impl Hash for Default

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

impl Hash for TypeTuple

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

impl Hash for ExprUnsafe

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

impl Hash for ExprArray

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

impl Hash for QSelf

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

impl Hash for ItemMod

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

impl Hash for Dot

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

impl Hash for ForeignItemMacro

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

impl Hash for At

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

impl Hash for ConstParam

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

impl Hash for ExprIf

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

impl Hash for ItemMacro2

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

impl Hash for MulEq

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

impl Hash for RArrow

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

impl Hash for Colon

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

impl Hash for Label

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

impl Hash for Struct

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

impl Hash for If

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

impl Hash for ExprRange

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

impl Hash for VisPublic

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

impl Hash for Yield

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

impl Hash for PatPath

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

impl Hash for ImplItemMethod

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

impl Hash for Try

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

impl Hash for Member

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

impl Hash for Rem

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

impl Hash for ImplItemMacro

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

impl Hash for Continue

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

impl Hash for Add

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

impl Hash for ExprContinue

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

impl Hash for TypeBareFn

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

impl Hash for Impl

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

impl Hash for ExprTuple

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

impl Hash for PatTupleStruct

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

impl Hash for PredicateType

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

impl Hash for Variadic

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

impl Hash for Shr

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

impl Hash for BareFnArg

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

impl Hash for Await

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

impl Hash for ExprMacro

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

impl Hash for Eq

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

impl Hash for ExprPath

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

impl Hash for ShrEq

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

impl Hash for Abi

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

impl Hash for ExprUnary

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

impl Hash for ForeignItemFn

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

impl Hash for LArrow

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

impl Hash for Receiver

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

impl Hash for MethodTurbofish

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

impl Hash for PatTuple

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

impl Hash for PredicateLifetime

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

impl<'a> Hash for ImplGenerics<'a>

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

impl Hash for ExprYield

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

impl Hash for Union

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

impl Hash for ForeignItemType

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

impl Hash for LitChar

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

impl Hash for DotDotEq

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

impl Hash for Data

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

impl Hash for Ne

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

impl Hash for TypeImplTrait

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

impl Hash for Bang

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

impl Hash for DataUnion

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

impl Hash for Macro

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

impl Hash for WhereClause

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

impl Hash for ItemMacro

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

impl Hash for TypeReference

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

impl Hash for ParenthesizedGenericArguments

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

impl Hash for ExprType

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

impl Hash for Ge

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

impl Hash for VisCrate

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

impl Hash for ExprClosure

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

impl Hash for Let

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

impl Hash for LitStr

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

impl Hash for Ref

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

impl Hash for Semi

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

impl Hash for Or

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

impl Hash for DeriveInput

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

impl Hash for Enum

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

impl Hash for TypeParen

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

impl Hash for ExprLet

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

impl Hash for TraitItem

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

impl Hash for Constraint

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

impl Hash for Generics

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

impl Hash for Stmt

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

impl Hash for ItemType

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

impl Hash for FieldPat

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

impl Hash for MetaNameValue

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

impl Hash for UseRename

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

impl Hash for Super

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

impl Hash for FieldsUnnamed

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

impl Hash for TraitBoundModifier

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

impl<'a> Hash for Turbofish<'a>

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

impl Hash for DataStruct

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

impl Hash for Type

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

impl Hash for PatOr

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

impl Hash for GenericParam

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

impl Hash for ExprBox

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

impl Hash for Match

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

impl Hash for ExprBlock

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

impl Hash for Block

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

impl Hash for PatRange

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

impl Hash for DivEq

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

impl Hash for TypePath

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

impl Hash for ExprForLoop

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

impl Hash for ExprAwait

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

impl Hash for Unsized

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

impl Hash for Else

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

impl Hash for Abstract

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

impl Hash for ExprBreak

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

impl Hash for Bracket

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

impl Hash for ItemExternCrate

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

impl Hash for ExprCall

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

impl Hash for Dollar

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

impl Hash for TypeArray

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

impl Hash for Arm

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

impl Hash for ExprCast

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

impl Hash for Group

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

impl Hash for ImplItem

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

impl Hash for PatLit

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

impl Hash for TypeParamBound

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

impl Hash for Macro

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

impl Hash for TypePtr

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

impl Hash for ExprField

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

impl Hash for UseGroup

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

impl Hash for Signature

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

Loading content...

Implementors

impl Hash for DefaultLevels

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

impl Hash for enso_flexer::prelude::fmt::Error

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

impl Hash for enso_flexer::prelude::logger::entry::level::filter_from::Debug

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

impl Hash for enso_flexer::prelude::logger::entry::level::filter_from::Error

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

impl Hash for enso_flexer::prelude::logger::entry::level::filter_from::Info

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

impl Hash for enso_flexer::prelude::logger::entry::level::filter_from::Trace

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

impl Hash for enso_flexer::prelude::logger::entry::level::filter_from::Warning

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

impl Hash for enso_flexer::prelude::logger::entry::level::Debug

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

impl Hash for enso_flexer::prelude::logger::entry::level::Error

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

impl Hash for enso_flexer::prelude::logger::entry::level::Info

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

impl Hash for enso_flexer::prelude::logger::entry::level::Trace

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

impl Hash for enso_flexer::prelude::logger::entry::level::Warning

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

impl Hash for ImString

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

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_flexer::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 for Switch<T> where
    T: Hash, 

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

Loading content...