Stored page text, served from the archive.
Stored text only -- layout, images, and scripts from the original page are not preserved.
Lib .rs › Data structures | Algorithms # perfect-hash # compile-time # run-time # static # perfect-hash-function # lookup-tables # phf-codegen no-std phf Runtime support for perfect hash function data structures by Steven Fackler , Yuki Okushi , Austin Bonander and 65 contributors Audit Install API reference GitHub repo ( rust-phf ) 69 releases Uses new Rust 2024 0.14.0 Jun 21, 2026 0.13.1 Aug 23, 2025 0.12.1 Jun 19, 2025 0.11.3 Jan 6, 2025 0.1.0 Nov 27, 2014 # 4 in Data structures 94,290,176 downloads per month Used in 21,888 crates (1,243 directly) MIT license 70KB 1.5K SLoC Rust-PHF Documentation Rust-PHF is a library to generate efficient lookup tables at compile time using perfect hash functions . It currently uses the CHD algorithm by default and also ships an experimental ptrhash feature for an alternative MPHF layout. MSRV (minimum supported rust version) is Rust 1.85. Usage PHF data structures can be constructed via either the procedural macros in the phf_macros crate or code generation supported by the phf_codegen crate.
To compile the phf crate with a dependency on libcore instead of libstd, enabling use in environments where libstd will not work, set default - features = false for the dependency: [dependencies] # to use `phf` in `no_std` environments phf = { version = "0.14.0", default-features = false } phf_macros use phf::phf_map; #[derive(Clone)] pub enum Keyword { Loop, Continue, Break, Fn, Extern, } static KEYWORDS: phf::Map<&'static str, Keyword> = phf_map! { "loop" => Keyword::Loop, "continue" => Keyword::Continue, "break" => Keyword::Break, "fn" => Keyword::Fn, "extern" => Keyword::Extern, }; // You can also use OR (`|`) patterns to map multiple keys to the same value: static OPERATORS: phf::Map<&'static str, &'static str> = phf_map! { "+" | "add" | "plus" => "addition", "-" | "sub" | "minus" => "subtraction", "*" | "mul" | "times" => "multiplication", }; pub fn parse_keyword(keyword: &str) -> Option<Keyword> { KEYWORDS.get(keyword).cloned() } pub fn parse_operator(operator: &str) -> Option<&'static str> { OPERATORS.get(operator).copied() } [dependencies] phf = { version = "0.14.0", features = ["macros"] } To try the experimental alternative, enable ptrhash on both the generator and runtime crates you use: [dependencies] phf = { version = "0.14.0", features = ["macros", "ptrhash"] } Note Currently, the macro syntax has some limitations and may not work as you want. See #196 for example.
Integer literals in the first key's type shape must use explicit suffixes, such as 0 u32 , [ 0 u8 , 1 ] , or ( 0 u32 , 1 u32 ) ; later keys infer unsuffixed integer literals from the same position in that first key. Tuple keys are supported up to 12 elements. All keys must use the same supported key expression type as the first key. phf_codegen To use phf_codegen on build.rs, you have to add dependencies under [ build-dependencies ] : [build-dependencies] phf = { version = "0.14.0", default-features = false } phf_codegen = "0.14.0" When using the experimental ptrhash layout, enable the ptrhash feature on both phf_codegen and the runtime phf dependency so the generated constants match the runtime struct layout.
Then put code on build.rs: use std::env; use std::fs::File; use std::io::{BufWriter, Write}; use std::path::Path; fn main() { let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs"); let mut file = BufWriter::new(File::create(&path).unwrap()); write!( &mut file, "static KEYWORDS: phf::Map<&'static str, Keyword> = {}", phf_codegen::Map::new() .entry("loop", "Keyword::Loop") .entry("continue", "Keyword::Continue") .entry("break", "Keyword::Break") .entry("fn", "Keyword::Fn") .entry("extern", "Keyword::Extern") .build() ) .unwrap(); write!(&mut file, ";\n").unwrap(); // Example with OR patterns (note: phf_codegen doesn't support OR patterns directly) write!( &mut file, "static OPERATORS: phf::Map<&'static str, &'static str> = {}", phf_codegen::Map::new() .entry("+", "\"addition\"") .entry("add", "\"addition\"") .entry("plus", "\"addition\"") .entry("-", "\"subtraction\"") .entry("sub", "\"subtraction\"") .entry("minus", "\"subtraction\"") .build() ) .unwrap(); write!(&mut file, ";\n").unwrap(); } and lib.rs: #[derive(Clone)] enum Keyword { Loop, Continue, Break, Fn, Extern, } include!(concat!(env!("OUT_DIR"), "/codegen.rs")); pub fn parse_keyword(keyword: &str) -> Option<Keyword> { KEYWORDS.get(keyword).cloned() } pub fn parse_operator(operator: &str) -> Option<&'static str> { OPERATORS.get(operator).copied() } Dependencies ~48–260KB macros? ptrhash? uncased? unicase?
phf_ macros 0.14 phf_ shared 0.14 serde? std? serde Related: phf_codegen , phf_shared , phf_generator , phf_macros See also: hashbrown , indexmap , tinyvec , fixedbitset , hashlink , arrayvec , bit-vec , petgraph , either , hybrid-array , bit-set Lib.rs is an unofficial list of Rust/Cargo crates, created by kornelski . It contains data from multiple sources, including heuristics, and manually curated data .
Content of this page is not necessarily endorsed by the authors of the crate. This site is not affiliated with nor endorsed by the Rust Project. If something is missing or incorrect, please file a bug .