Trait Hash 

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

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

Custom trait to avoid issues like https://github.com/rust-lang/rust/issues/27108.

Required Methods

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

where H: Hasher,

Provided Methods

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

where H: Hasher, Self: Sized,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Hash for bool

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

where H: Hasher,

impl Hash for char

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

where H: Hasher,

impl Hash for i8

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i16

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i32

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i64

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i128

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

where H: Hasher,

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

where H: Hasher,

impl Hash for isize

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

where H: Hasher,

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

where H: Hasher,

impl Hash for str

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

where H: Hasher,

impl Hash for u8

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u16

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u32

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u64

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u128

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

where H: Hasher,

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

where H: Hasher,

impl Hash for ()

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

where H: Hasher,

impl Hash for usize

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

where H: Hasher,

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

where H: Hasher,

impl Hash for String

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

where H: Hasher,

impl<A> Hash for (A,)

where A: Hash + ?Sized,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

impl<A, B> Hash for (A, B)

where A: Hash, B: Hash + ?Sized,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

impl<A, B, C> Hash for (A, B, C)

where A: Hash, B: Hash, C: Hash + ?Sized,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

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

where A: Hash, B: Hash, C: Hash, D: Hash + ?Sized,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

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,

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 A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash + ?Sized,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

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,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

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,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

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,

fn hash<S>(&self, state: &mut S)

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

fn hash<S>(&self, state: &mut S)

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

fn hash<S>(&self, state: &mut S)

where S: 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 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,

fn hash<S>(&self, state: &mut S)

where S: Hasher,

impl<T> Hash for *const T

where T: ?Sized,

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

where H: Hasher,

impl<T> Hash for *mut T

where T: ?Sized,

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

where H: Hasher,

impl<T> Hash for &T

where T: Hash + ?Sized,

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

where H: Hasher,

impl<T> Hash for &mut T

where T: Hash + ?Sized,

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

where H: Hasher,

impl<T> Hash for [T]

where T: Hash,

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

where H: Hasher,

impl<T> Hash for Vec<T>

where T: Hash,

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

where H: Hasher,

Implementors

impl Hash for BytesKey