core::hash::Hash - Rust
Description: API documentation for the Rust `Hash` trait in crate `core`.
Keywords: rust, rustlang, rust-lang, Hash

# 1.0.0[−][src]Trait core::hash::Hash

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

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

A hashable type.

Types implementing `Hash` are able to be `hash`ed 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,
    }

Run

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

Run

## `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: Hasher>(&self, state: &mut H)`

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

Run
Loading content...

## Provided methods

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

Feeds a slice of this type into the given `Hasher`.

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

Run
Loading content...

## Implementors

### `impl Hash for !`[src]

#### `fn hash<H: Hasher>(&self, _: &mut H)`[src]

### `impl Hash for ()`[src]

#### `fn hash<H: Hasher>(&self, _state: &mut H)`[src]

### `impl Hash for core::cmp::Ordering`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for core::sync::atomic::Ordering`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for TypeId`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for Error`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for PhantomPinned`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroI128`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroI16`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroI32`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroI64`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroI8`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroIsize`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroU128`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroU16`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroU32`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroU64`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroU8`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NonZeroUsize`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for RangeFull`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for NoneError`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for Duration`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl Hash for bool`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl Hash for char`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl Hash for i8`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[i8], state: &mut H)`[src]

### `impl Hash for i16`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[i16], state: &mut H)`[src]

### `impl Hash for i32`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[i32], state: &mut H)`[src]

### `impl Hash for i64`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[i64], state: &mut H)`[src]

### `impl Hash for i128`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[i128], state: &mut H)`[src]

### `impl Hash for isize`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[isize], state: &mut H)`[src]

### `impl Hash for str`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl Hash for u8`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[u8], state: &mut H)`[src]

### `impl Hash for u16`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[u16], state: &mut H)`[src]

### `impl Hash for u32`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[u32], state: &mut H)`[src]

### `impl Hash for u64`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[u64], state: &mut H)`[src]

### `impl Hash for u128`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[u128], state: &mut H)`[src]

### `impl Hash for usize`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

#### `fn hash_slice<H: Hasher>(data: &[usize], state: &mut H)`[src]

### `impl<'_, T: ?Sized + Hash> Hash for &'_ T`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<'_, T: ?Sized + Hash> Hash for &'_ mut T`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<A> Hash for (A,) where
A: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<A: Hash, B> Hash for (A, B) where
B: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<A: Hash, B: Hash, C> Hash for (A, B, C) where
C: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<A: Hash, B: Hash, C: Hash, D> Hash for (A, B, C, D) where
D: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<A: Hash, B: Hash, C: Hash, D: Hash, E> Hash for (A, B, C, D, E) where
E: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F> Hash for (A, B, C, D, E, F) where
F: Hash + ?Sized,` [src]

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

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

#### `fn hash<S: Hasher>(&self, state: &mut S)`[src]

### `impl<Idx: Hash> Hash for Range<Idx>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<Idx: Hash> Hash for RangeFrom<Idx>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<Idx: Hash> Hash for RangeInclusive<Idx>`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<Idx: Hash> Hash for RangeTo<Idx>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<Idx: Hash> Hash for RangeToInclusive<Idx>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<P: Deref<Target: Hash>> Hash for Pin<P>`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<Ret> Hash for extern "C" fn() -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret> Hash for fn() -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret> Hash for unsafe extern "C" fn() -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret> Hash for unsafe fn() -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for extern "C" fn(_: A) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for extern "C" fn(_: A, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for fn(_: A) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for unsafe extern "C" fn(_: A) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for unsafe extern "C" fn(_: A, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A> Hash for unsafe fn(_: A) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for extern "C" fn(_: A, _: B) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for extern "C" fn(_: A, _: B, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for fn(_: A, _: B) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for unsafe extern "C" fn(_: A, _: B) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for unsafe extern "C" fn(_: A, _: B, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B> Hash for unsafe fn(_: A, _: B) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for extern "C" fn(_: A, _: B, _: C) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for extern "C" fn(_: A, _: B, _: C, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for fn(_: A, _: B, _: C) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C> Hash for unsafe fn(_: A, _: B, _: C) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for fn(_: A, _: B, _: C, _: D) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D> Hash for unsafe fn(_: A, _: B, _: C, _: D) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for fn(_: A, _: B, _: C, _: D, _: E) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E> Hash for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G> Hash for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<Ret, A, B, C, D, E, F, G, H, I> Hash for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `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`[src]

#### `fn hash<HH: Hasher>(&self, state: &mut HH)`[src]

### `impl<T> Hash for Discriminant<T>`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<T: Hash + ?Sized> Hash for ManuallyDrop<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for Bound<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for Option<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for Poll<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for Reverse<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for Wrapping<T>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash> Hash for [T]`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<T: Hash, E: Hash> Hash for Result<T, E>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

### `impl<T: Hash, const N: usize> Hash for [T; N] where
[T; N]: LengthAtMost32,` [src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<T: ?Sized> Hash for *const T`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<T: ?Sized> Hash for *mut T`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<T: ?Sized> Hash for PhantomData<T>`[src]

#### `fn hash<H: Hasher>(&self, _: &mut H)`[src]

### `impl<T: ?Sized> Hash for NonNull<T>`[src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

### `impl<Y: Hash, R: Hash> Hash for GeneratorState<Y, R>`[src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

Loading content...