digest

The `digest` crate provides the foundational traits for working with cryptographic hash functions in Rust, and it does this exceptionally well. The API is remarkably straightforward - you just import `Digest` trait and call `update()` to feed data, then `finalize()` to get the hash. The trait-based design means you can write generic code that works with any hash algorithm (SHA-256, SHA-3, BLAKE2, etc.) without vendor lock-in.

Error messages are clear when you make mistakes like trying to use a digest after finalization. The documentation includes practical examples showing both one-shot hashing with `digest()` and incremental hashing for streaming data. Type safety is excellent - the output size is encoded in the type system via `Output<Self>`, preventing runtime errors.

Day-to-day usage is friction-free. Common patterns like hashing files in chunks or implementing HMAC are straightforward. The ecosystem of hash implementations (sha2, blake3, etc.) all implement these traits consistently, so switching algorithms is literally a one-line change. Stack Overflow has decent coverage, and the RustCrypto GitHub is responsive to issues.

The `digest` crate provides the foundational traits for cryptographic hashing in Rust's ecosystem. Day-to-day usage is straightforward once you understand the trait-based approach. You'll typically import traits like `Digest` and `Update`, then work with concrete implementations from crates like `sha2` or `blake3`. The API is consistent across all hash functions, making it easy to swap implementations.

Type safety is excellent—the generic `Output` types and `OutputSizeUser` trait ensure compile-time guarantees about digest sizes. The builder pattern with `update()` and `finalize()` feels natural, and the `digest!` macro provides convenient one-shot hashing. Error messages are generally clear when you forget to import the right traits.

The main friction point is the learning curve around trait imports and the distinction between `Digest`, `DynDigest`, and `FixedOutput`. Documentation has improved significantly but could use more practical examples showing common patterns like HMAC construction or incremental hashing of large files. Version 0.10+ introduced breaking changes that required careful migration, though the benefits (better const generics support) were worth it.

The digest crate is foundational infrastructure that does exactly one thing perfectly: provides trait abstractions for cryptographic hash functions. In production, this means you can write generic code over hash algorithms without runtime overhead. The traits compile down to monomorphized implementations with no vtable indirection, which matters when you're hashing millions of messages.

The API is beautifully minimal. The `Digest` trait with `update()`, `finalize()`, and `finalize_reset()` methods covers 99% of use cases. The `FixedOutput` and `ExtendableOutput` traits handle the type-level differences between hash families cleanly. Error handling is non-existent because these are infallible operations—no spurious Results to unwrap. Memory usage is predictable: stack-allocated state machines with known sizes.

Breaking changes between 0.9, 0.10, and 0.11 required dependency coordination across the ecosystem, but each version improved ergonomics significantly. The 0.10+ series stabilized the API around const generics, making output size handling much cleaner. Runtime performance is literally a non-issue—this is just trait definitions that disappear at compile time.