These free functions cover a byte checksum, seeded and unseeded 64-bit hashes, and a multi-seed hash that fills an output slice in one pass.

pub fn bytesum<T: AsRef<[u8]>>(text: T) -> u64;
pub fn hash<T: AsRef<[u8]>>(text: T) -> u64;
pub fn hash_with_seed<T: AsRef<[u8]>>(text: T, seed: u64) -> u64;
pub fn hash_multiseed_into<T: AsRef<[u8]>>(text: T, seeds: &[u64], out: &mut [u64]) -> Result<(), Status>;

bytesum is an order-insensitive byte sum; hash / hash_with_seed are order-sensitive AES-based 64-bit hashes. hash_multiseed_into hashes one input under many seeds in a single pass, handy for MinHash, Count-Min sketches, and Bloom/cuckoo filters; it returns Status::UnexpectedDimensions if out.len() != seeds.len():

use stringzilla as sz;

assert_eq!(sz::bytesum("hi"), 209);
assert_ne!(sz::hash("Hello"), sz::hash("World"));
assert_eq!(sz::hash_with_seed("Hello", 42), sz::hash_with_seed("Hello", 42));

let seeds = [1u64, 2, 3, 4];
let mut out = [0u64; 4];
sz::hash_multiseed_into("token", &seeds, &mut out).unwrap();

These are also available as StringZillableUnary methods on any AsRef<[u8]>:

use stringzilla::StringZillableUnary;

assert_eq!(b"Hello".sz_bytesum(), 500);
assert_ne!(b"Hello".sz_hash(), b"World".sz_hash());

§ Incremental Hashing

Hasher is an incremental AES-based hasher implementing core::hash::Hasher:

use stringzilla::Hasher;

let mut hasher = Hasher::new(123);
hasher.update(b"Hello, ").update(b"world!");
assert_eq!(hasher.digest(), Hasher::new(123).update(b"Hello, world!").digest());

Hasher API: new(seed), update(&mut self, &[u8]) -> &mut Self, digest(&self) -> u64, plus the full core::hash::Hasher trait.

With the std feature, BuildSzHasher plugs the AES-based hash into the standard HashMap and HashSet as their hasher, replacing the default SipHash. For string keys this swaps a scalar hash for StringZilla’s vectorized one while keeping the entire collection API unchanged. The seed defaults to 0 and is deterministic across runs, so pass a random seed through with_seed when you want per-process resistance to hash-flooding:

use std::collections::{HashMap, HashSet};
use stringzilla::BuildSzHasher;

let mut counts: HashMap<&str, i32, BuildSzHasher> = HashMap::with_hasher(BuildSzHasher::with_seed(0));
for word in ["apple", "banana", "apple"] { *counts.entry(word).or_insert(0) += 1; }
assert_eq!(counts["apple"], 2);

let mut seen: HashSet<&str, BuildSzHasher> = HashSet::with_hasher(BuildSzHasher::with_seed(42));
seen.insert("apple");
seen.insert("banana");
assert!(seen.contains("apple"));
assert_eq!(seen.len(), 2);

§ SHA-256 and HMAC

hmac_sha256 computes a keyed HMAC-SHA-256 over a message, returning a 32-byte tag. hmac_sha256_multistate authenticates many messages under one key at once — a batch of tokens or webhook bodies sharing a secret — running both the message pass and HMAC’s outer wrap through the lane-parallel kernels. It allocates nothing, so it works under no_std: states is scratch of one state per message, reused for both passes, and only tags is written for keeps.

pub fn hmac_sha256(key: &[u8], message: &[u8]) -> Sha256Digest;
pub fn hmac_sha256_multistate<Element: AsRef<[u8]>>(
    key: &[u8],
    messages: &[Element],
    states: &mut [Sha256],
    tags: &mut [Sha256Digest],
) -> Result<(), Status>;

Sha256 supports one-shot and incremental hashing, returning a 32-byte digest:

use stringzilla::{Sha256, hmac_sha256};

let digest = Sha256::hash(b"Hello, world!");
assert_eq!(digest.len(), 32);

let mut hasher = Sha256::new();
hasher.update(b"Hello, ").update(b"world!");
assert_eq!(hasher.digest(), digest);

let mac = hmac_sha256(b"secret_key", b"important message");
assert_eq!(mac.len(), 32);

Sha256 API: new(), update(&mut self, &[u8]) -> &mut Self, digest(&self) -> Sha256Digest, hash(&[u8]) -> Sha256Digest, where Sha256Digest is [u8; SHA256_DIGEST_LENGTH].

Digesting one message is a serial dependency chain, but independent messages compress in parallel lanes — sixteen at a time on AVX-512, eight on AVX2. sha256_multistate_update advances one hasher per message, taking anything that dereferences to bytes, so a Vec<String> needs no intermediate slice of slices. Use sha256_multistate_update_by(&mut states, &records, |record| record.payload.as_bytes()) when each message is a field of a larger element.

Lanes advance in lockstep within a group, so a group costs as much as its longest message. Every length is handled correctly, but throughput is best when messages of similar length share a group, which argsort arranges.

use stringzilla as sz;

let texts: Vec<String> = vec!["alpha".into(), "beta".into()];
let mut states = vec![sz::Sha256::new(); texts.len()];
let mut digests = vec![[0u8; 32]; texts.len()];

sz::sha256_multistate_update(&mut states, &texts).unwrap();
sz::sha256_multistate_digest(&states, &mut digests).unwrap();
assert_eq!(digests[0], sz::Sha256::hash(b"alpha"));