# [−] [src] Trait hash32::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,
            Self: Sized,
        { ... }
    }

See `core::hash::Hash` for details

## Required methods

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

Feeds this value into the given `Hasher`.

Loading content...

## Provided methods

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

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

Loading content...

## Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl<'a, T: ?Sized + Hash> Hash for &'a 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<T> Hash for [T; 0] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 1] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 2] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 3] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 4] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 5] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 6] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 7] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 8] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 9] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 10] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 11] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 12] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 13] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 14] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 15] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 16] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 17] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 18] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 19] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 20] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 21] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 22] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 23] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 24] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 25] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 26] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 27] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 28] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 29] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 30] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 31] where
T: Hash,` [src]

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

### `impl<T> Hash for [T; 32] where
T: Hash,` [src]

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

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

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

Loading content...