1.0.0[][src]Trait nom::lib::std::hash::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

Feeds this value into the given Hasher.

Examples

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

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

Provided Methods

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

Implementations on Foreign Types

impl Hash for SocketAddr
[src]

impl<'a> Hash for Prefix<'a>
[src]

impl Hash for Instant
[src]

impl<'a> Hash for Component<'a>
[src]

impl Hash for ErrorKind
[src]

impl Hash for ThreadId
[src]

impl Hash for SystemTime
[src]

impl Hash for OsStr
[src]

impl Hash for Path
[src]

impl Hash for OsString
[src]

impl<'a> Hash for PrefixComponent<'a>
[src]

impl Hash for SocketAddrV4
[src]

impl Hash for FileType
[src]

impl Hash for PathBuf
[src]

impl Hash for CString
[src]

impl Hash for IpAddr
[src]

impl Hash for Ipv4Addr
[src]

impl Hash for SocketAddrV6
[src]

impl Hash for Ipv6Addr
[src]

impl Hash for CStr
[src]

impl Hash for Ipv6MulticastScope
[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]

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

impl Hash for TypeId
[src]

impl Hash for NonZeroU16
[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]

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

impl Hash for u16
[src]

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

impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
[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]

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

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

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

impl Hash for str
[src]

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

impl Hash for u64
[src]

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

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

impl Hash for i16
[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]

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

impl Hash for !
[src]

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

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

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

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

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

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

impl Hash for usize
[src]

impl<T> Hash for *mut T where
    T: ?Sized
[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]

impl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G) where
    A: Hash,
    B: Hash,
    C: Hash,
    D: Hash,
    E: Hash,
    F: Hash,
    G: Hash + ?Sized
[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]

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]

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

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

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

impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
[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]

impl Hash for NonZeroU32
[src]

impl<T> Hash for [T; 18] where
    T: Hash
[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]

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

impl Hash for ()
[src]

impl Hash for NonZeroU64
[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]

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

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

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

impl<T> Hash for Poll<T> where
    T: Hash
[src]

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

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

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

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

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

impl Hash for i32
[src]

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

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

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

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

impl Hash for char
[src]

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

impl Hash for u32
[src]

impl<T> Hash for [T; 6] where
    T: Hash
[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]

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

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

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

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

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

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

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

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

impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C) -> Ret
[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]

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

impl<T> Hash for [T; 0] where
    T: Hash
[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]

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

impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret
[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]

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

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

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

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

impl Hash for NonZeroU8
[src]

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

impl Hash for isize
[src]

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

impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(A, B, C, D, E, F) -> Ret
[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]

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

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

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

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

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

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

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

impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret
[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]

impl Hash for u8
[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]

impl Hash for bool
[src]

impl Hash for Duration
[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]

impl<T> Hash for [T; 1] where
    T: Hash
[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]

impl<T> Hash for [T; 5] where
    T: Hash
[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]

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]

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]

impl Hash for Pinned
[src]

impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(A, B, C, D, E, F, G, H) -> Ret
[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]

impl<T> Hash for Wrapping<T> where
    T: Hash
[src]

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

impl Hash for NonZeroU128
[src]

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

impl<T> Hash for [T; 19] where
    T: Hash
[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]

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

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

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

impl Hash for i128
[src]

impl<Ret, A> Hash for fn(A) -> Ret
[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]

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

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

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

impl Hash for i8
[src]

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

impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
[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]

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

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

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

impl Hash for u128
[src]

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

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

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

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

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

impl<T> Hash for [T; 32] where
    T: Hash
[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]

impl Hash for i64
[src]

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

impl Hash for NonZeroUsize
[src]

impl<A, B, C, D> Hash for (A, B, C, D) where
    A: Hash,
    B: Hash,
    C: Hash,
    D: Hash + ?Sized
[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]

impl<T> Hash for [T; 31] where
    T: Hash
[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]

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]

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

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

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

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

impl<T> Hash for Rc<T> where
    T: Hash + ?Sized
[src]

impl<T> Hash for Arc<T> where
    T: Hash + ?Sized
[src]

Implementors

impl Hash for Ordering
[src]

impl Hash for Error
[src]

impl Hash for RangeFull
[src]

impl Hash for NoneError
[src]

impl Hash for String
[src]

impl<'a> Hash for CompleteByteSlice<'a>
[src]

impl<'a> Hash for CompleteStr<'a>
[src]

impl<A> Hash for VecDeque<A> where
    A: Hash
[src]

impl<E: Hash> Hash for nom::ErrorKind<E>
[src]

impl<Idx> Hash for Range<Idx> where
    Idx: Hash
[src]

impl<Idx> Hash for RangeFrom<Idx> where
    Idx: Hash
[src]

impl<Idx> Hash for RangeInclusive<Idx> where
    Idx: Hash
[src]

impl<Idx> Hash for RangeTo<Idx> where
    Idx: Hash
[src]

impl<Idx> Hash for RangeToInclusive<Idx> where
    Idx: Hash
[src]

impl<K, V> Hash for BTreeMap<K, V> where
    K: Hash,
    V: Hash
[src]

impl<T> Hash for Bound<T> where
    T: Hash
[src]

impl<T> Hash for Option<T> where
    T: Hash
[src]

impl<T> Hash for Reverse<T> where
    T: Hash
[src]

impl<T> Hash for LinkedList<T> where
    T: Hash
[src]

impl<T> Hash for BTreeSet<T> where
    T: Hash
[src]

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

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

impl<T> Hash for Box<T> where
    T: Hash + ?Sized
[src]

impl<T> Hash for Vec<T> where
    T: Hash
[src]

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

impl<T: Hash> Hash for Input<T>
[src]

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