Document byte-wise hashing.

Fixes #97.

Author: nnethercote

src/hashing.md

@@ -1,10 +1,14 @@
 # Hashing
 
-`HashSet` and `HashMap` are two widely-used types. The default hashing
-algorithm is not specified, but at the time of writing the default is an
-algorithm called [SipHash 1-3]. This algorithm is high quality—it provides high
-protection against collisions—but is relatively slow, particularly for short keys
-such as integers.
+`HashSet` and `HashMap` are two widely-used types and there are ways to make
+them faster.
+
+## Alternative Hashers
+
+The default hashing algorithm is not specified, but at the time of writing the
+default is an algorithm called [SipHash 1-3]. This algorithm is high quality—it
+provides high protection against collisions—but is relatively slow,
+particularly for short keys such as integers.
 
 [SipHash 1-3]: https://en.wikipedia.org/wiki/SipHash
 
@@ -58,3 +62,23 @@ Hash function design is a complex topic and is beyond the scope of this book.
 The [`ahash` documentation] has a good discussion. 
 
 [`ahash` documentation]: https://github.com/tkaitchuck/aHash/blob/master/compare/readme.md
+
+## Byte-wise Hashing
+
+When you annotate a type with `#[derive(Hash)]` the generated `hash` method
+will hash each field separately. For some hash functions it may be faster to
+convert the type to raw bytes and hash the bytes as a stream. This is possible
+for types that satisfy certain properties such as having no padding bytes.
+
+The [`zerocopy`] and [`bytemuck`] crates both provide a `#[derive(ByteHash)]`
+macro that generates a `hash` method that does this kind of byte-wise hashing.
+The README for the [`derive_hash_fast`] crate provides more detail for this
+technique.
+
+[`zerocopy`]: https://crates.io/crates/zerocopy
+[`bytemuck`]: https://crates.io/crates/bytemuck
+[`derive_hash_fast`]: https://crates.io/crates/derive_hash_fast
+
+This is an advanced technique, and the performance effects are highly dependent
+on the hash function and the exact structure of the types being hashed. Measure
+carefully.