precomputed-hash

precomputed-hash is a tiny, dependency-free Rust crate that defines a single trait, PrecomputedHash, for types whose hash value is computed once and cached rather than recomputed on every lookup. Implementors expose a precomputed_hash() method returning a u32, letting hash-map-heavy code reuse an already-known hash instead of re-hashing potentially large or Unicode-heavy strings each time.

It exists as a shared low-level primitive so unrelated crates — most notably string_cache and the interned-string types used throughout Servo’s style system — can agree on one trait for exposing precomputed hashes, avoiding duplicate definitions scattered across the dependency graph.

What You Get

• PrecomputedHash trait - a single-method trait exposing precomputed_hash(&self) -> u32 for any type that already knows its hash.
• Reference impls - blanket implementations for &T and &mut T so precomputed hashes propagate transparently through references.
• Zero dependencies - the crate declares no dependencies of its own, keeping it safe to sit deep in any dependency graph.
• MIT license - a permissive, unrestricted license with no attribution burden for embedding in other crates.

Common Use Cases

• Interned string hashing - string-interning crates like string_cache implement PrecomputedHash on their atoms so hash maps can reuse the hash computed at interning time.
• Servo style engine lookups - Servo’s CSS style system relies on precomputed hashes for selector and property caches to avoid re-hashing on every style resolution.
• Custom cache keys - any type used heavily as a hash map key can implement the trait once and let calling code avoid redundant hashing in hot loops.
• Cross-crate trait alignment - projects that want a shared, dependency-free trait for “already-hashed” types can depend on this crate instead of defining their own.

Under The Hood

Architecture precomputed-hash has no internal architecture beyond a single trait declaration in src/lib.rs: PrecomputedHash requires one method, precomputed_hash(&self) -> u32, and two blanket implementations forward that call through &T and &mut T via double-dereference. There are no modules, no internal state, and no data flow beyond a per-call method dispatch — the crate is a pure interface with zero implementation logic of its own, so downstream types (like Servo’s string_cache atoms) supply the actual hash-storage behavior. Because the trait method takes &self and returns a plain u32 with no associated type or generic parameter, any change to that signature would be a breaking API change across every implementor in the ecosystem, making the trait’s stability the crate’s entire architectural surface.

Tech Stack The crate targets stable Rust via a minimal Cargo.toml with an empty [dependencies] table — no runtime or dev dependencies are declared, and no build.rs, feature flags, or workspace configuration exist. It compiles as a plain rlib under Cargo’s default settings, needs no tooling beyond cargo build, and has no Dockerfile, CI workflow, or packaging scripts in the repository. Its footprint is defined entirely by the absence of choices: no async runtime, no macro dependencies, no explicit no_std opt-in despite being trivially no_std-compatible, and no version pinning beyond the crate’s own 0.1.1 release.

Code Quality There are no test files, no #[test] functions, and no CI workflow (no .github directory) anywhere in the repository, so the crate ships with zero automated verification of its two blanket trait implementations. Naming is clear and idiomatic (PrecomputedHash, precomputed_hash), and the two doc comments on the trait and its method are the only documentation artifacts; there is no README, CONTRIBUTING guide, or docs directory. Type safety is inherent to Rust’s trait system, but nothing enforces that a precomputed_hash() implementation stays consistent with a type’s Hash/Eq impls — that invariant is left entirely to convention, with no linter or formatter configuration checked into the repo.

What Makes It Unique precomputed-hash is intentionally unoriginal: its sole contribution is standardizing, in one dependency-free crate, the pattern of caching a hash value instead of recomputing it — a pattern many performance-sensitive crates would otherwise reinvent locally. Its value is coordination, not novelty: by existing as a tiny, stable, near-zero-risk dependency, it lets crates like string_cache and Servo’s style engine share one trait definition rather than each defining their own, avoiding duplicate-trait conflicts across a large dependency graph. There is no algorithmic or architectural innovation in the code itself — it is two blanket implementations forwarding a method call through a reference.