Struct NicknameTable 

pub struct NicknameTable { /* private fields */ }

Equivalence-class lookup table for given-name nicknames.

Each class is a Vec<String> of normalised forms that the table considers interchangeable. Two inputs are equivalent under the table iff their normalised forms appear in the same class — or are byte-identical after normalisation.

The type is Clone + Debug + PartialEq + Eq so it composes into crate::MatchConfig without surprises. Construction is cheap and allocates once per class; lookup is O(classes × entries) and is dominated by the table’s size, not the input string length.

Example

use worker_matcher::NicknameTable;

let t = NicknameTable::empty()
    .with_class(["Michael", "Mike", "Mickey"])
    .with_class(["Elizabeth", "Liz", "Beth"]);

assert!(t.are_equivalent("Mike", "Michael"));
assert!(t.are_equivalent("liz", "BETH"));
assert!(!t.are_equivalent("Michael", "Liz"));

Implementations

impl NicknameTable

pub fn empty() -> Self

Construct an empty table that considers every pair of distinct strings non-equivalent (identical strings remain trivially equal).

use worker_matcher::NicknameTable;
let t = NicknameTable::empty();
assert!(!t.are_equivalent("Mike", "Michael"));
assert!(t.are_equivalent("Mike", "Mike"));

pub fn with_class<I, S>(self, names: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Append an equivalence class to the table.

Each input string is normalised via crate::Normalizer::normalize_name before insertion so the table is closed under the same normalisation pipeline the matcher uses at lookup time. Duplicate or empty entries are silently dropped, and a class with fewer than two distinct normalised entries is dropped entirely (it would never make a pair equivalent).

use worker_matcher::NicknameTable;
let t = NicknameTable::empty().with_class(["Robert", "Bob", "Rob"]);
assert!(t.are_equivalent("BOB", "robert"));

pub fn are_equivalent(&self, a: &str, b: &str) -> bool

Return true iff a and b, after name normalisation, are considered the same worker by this table.

Identical normalised strings are trivially equivalent. Otherwise both inputs must appear in the same equivalence class.

use worker_matcher::NicknameTable;
let t = NicknameTable::english();
assert!(t.are_equivalent("Mike",  "Michael"));
assert!(t.are_equivalent("mike",  "MICHAEL"));   // case-insensitive
assert!(!t.are_equivalent("Mike", "Robert"));
assert!(t.are_equivalent("",       ""));         // trivially equal

pub fn is_empty(&self) -> bool

true iff the table contains no equivalence classes — equivalent to comparing with NicknameTable::empty but cheaper to test.

use worker_matcher::NicknameTable;
assert!(NicknameTable::empty().is_empty());
assert!(!NicknameTable::english().is_empty());

pub fn len(&self) -> usize

Number of equivalence classes registered with this table.

use worker_matcher::NicknameTable;
assert_eq!(NicknameTable::empty().len(), 0);
let t = NicknameTable::empty().with_class(["A", "B"]);
assert_eq!(t.len(), 1);

pub fn english() -> Self

A built-in table covering the most common English-language nicknames encountered in healthcare data: Michael/Mike, Robert/Bob, Elizabeth/Liz, and similar.

The exact contents are not part of the public contract — entries may be added in minor releases. Callers that need a stable dictionary SHOULD construct their own via NicknameTable::with_class.

use worker_matcher::NicknameTable;
let t = NicknameTable::english();
assert!(t.are_equivalent("Bill",      "William"));
assert!(t.are_equivalent("Liz",       "Elizabeth"));
assert!(t.are_equivalent("Steve",     "Steven"));
assert!(t.are_equivalent("Steve",     "Stephen"));

Trait Implementations

impl Clone for NicknameTable

fn clone(&self) -> NicknameTable

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NicknameTable

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NicknameTable

fn default() -> NicknameTable

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NicknameTable

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NicknameTable

fn eq(&self, other: &NicknameTable) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NicknameTable

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for NicknameTable

impl StructuralPartialEq for NicknameTable