std::hash - Rust
Description: API documentation for the Rust `hash` mod in crate `std`.
Keywords: rust, rustlang, rust-lang, hash

# 1.0.0[−][src]Module std::hash

Generic hashing support.

This module provides a generic way to compute the hash of a value. The simplest way to make a type hashable is to use `#[derive(Hash)]`:

# Examples

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

    #[derive(Hash)]
    struct Person {
        id: u32,
        name: String,
        phone: u64,
    }

    let person1 = Person {
        id: 5,
        name: "Janet".to_string(),
        phone: 555_666_7777,
    };
    let person2 = Person {
        id: 5,
        name: "Bob".to_string(),
        phone: 555_666_7777,
    };

    assert!(calculate_hash(&person1) != calculate_hash(&person2));

    fn calculate_hash<T: Hash>(t: &T) -> u64 {
        let mut s = DefaultHasher::new();
        t.hash(&mut s);
        s.finish()
    }Run

If you need more control over how a value is hashed, you need to implement the `Hash` trait:

    use std::collections::hash_map::DefaultHasher;
    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);
        }
    }

    let person1 = Person {
        id: 5,
        name: "Janet".to_string(),
        phone: 555_666_7777,
    };
    let person2 = Person {
        id: 5,
        name: "Bob".to_string(),
        phone: 555_666_7777,
    };

    assert_eq!(calculate_hash(&person1), calculate_hash(&person2));

    fn calculate_hash<T: Hash>(t: &T) -> u64 {
        let mut s = DefaultHasher::new();
        t.hash(&mut s);
        s.finish()
    }Run

## Structs

BuildHasherDefault | Used to create a default `BuildHasher` instance for types that implement `Hasher` and `Default`.
SipHasher | [ Deprecated ] An implementation of SipHash 2-4.

## Traits

BuildHasher | A trait for creating instances of `Hasher`.
Hash | A hashable type.
Hasher | A trait for hashing an arbitrary stream of bytes.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)