# Trait std::hash::Hash
[−]
[src]

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.

The `H`

type parameter is an abstract hash state that is used by the `Hash`

to compute the hash.

If you are also implementing `Eq`

, there is an additional property that
is important:

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

In other words, if two keys are equal, their hashes should also be equal.
`HashMap`

and `HashSet`

both rely on this behavior.

This trait can be used with `#[derive]`

.

## Required Methods

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

Feeds this value into the state given, updating the hasher as necessary.

## Provided Methods

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

1.3.0

Feeds a slice of this type into the state provided.

## Implementors

`impl<T> Hash for *mut T`

`impl<T> Hash for *const T`

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

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

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

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

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

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

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

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

`impl<A, B, C, D, E> Hash for (A, B, C, D, E) where E: Hash, B: Hash, A: Hash, D: Hash, C: Hash`

`impl<A, B, C, D> Hash for (A, B, C, D) where D: Hash, A: Hash, C: Hash, B: Hash`

`impl<A, B, C> Hash for (A, B, C) where A: Hash, B: Hash, C: Hash`

`impl<A, B> Hash for (A, B) where A: Hash, B: Hash`

`impl<A> Hash for (A,) where A: Hash`

`impl Hash for ()`

`impl Hash for str`

`impl Hash for char`

`impl Hash for bool`

`impl Hash for isize`

`impl Hash for i64`

`impl Hash for i32`

`impl Hash for i16`

`impl Hash for i8`

`impl Hash for usize`

`impl Hash for u64`

`impl Hash for u32`

`impl Hash for u16`

`impl Hash for u8`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<T> Hash for [T; 0] where T: Hash`

`impl Hash for TypeId`

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

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

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

`impl<T> Hash for Box<T> where T: Hash + ?Sized`

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

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

`impl Hash for String`

`impl<T> Hash for Vec<T> where T: Hash`

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

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

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

`impl<A> Hash for LinkedList<A> where A: Hash`

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

`impl Hash for CString`

`impl Hash for CStr`

`impl Hash for OsString`

`impl Hash for OsStr`

`impl Hash for FileType`

`impl Hash for IpAddr`

`impl Hash for Ipv6MulticastScope`

`impl Hash for Ipv4Addr`

`impl Hash for Ipv6Addr`

`impl Hash for SocketAddr`

`impl Hash for SocketAddrV4`

`impl Hash for SocketAddrV6`

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

`impl<'a> Hash for PrefixComponent<'a>`

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

`impl Hash for PathBuf`

`impl Hash for Path`

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

`impl Hash for Duration`