Struct Interner 

pub struct Interner<T, B = <T as DefaultBackendBuilder>::Backend, H = RandomState>
where
    T: Hash + Eq + PartialEq + ?Sized,
    H: BuildHasher,
    B: Backend<T>,
{ /* private fields */ }

Interner

This struct is responsible for tracking objects and interning them.

Example

use interns::*;

let mut interner = Interner::<str>::default();

let a = interner.get_or_intern("hello");
let b = interner.get_or_intern("world");
let c = interner.get_or_intern("hello");

let a_resolv = interner.resolve(a);
let b_resolv = interner.resolve(b);
let c_resolv = interner.resolve(c);

assert_eq!(a_resolv, Some("hello"));
assert_eq!(b_resolv, Some("world"));
assert_eq!(c_resolv, Some("hello"));

assert_eq!(a, c);
assert_ne!(a, b);
assert_ne!(b, c);

Implementations

impl<T, B, H> Interner<T, B, H>

where T: Hash + Eq + PartialEq + ?Sized, H: BuildHasher, B: Backend<T>,

pub fn new() -> Self

where B: Default, H: Default,

Create a new Interner with a default backend and hasher

Examples found in repository

examples/string.rs (line 7)

pub fn main() -> io::Result<()> {
    let mut interner: Interner<str> = Interner::new();

    let mut words = HashSet::new();
    let mut line = String::new();
    loop {
        line.clear();
        print!("> ");
        stdout().flush()?;

        stdin().read_line(&mut line)?;
        let linet = line.trim();
        if linet.is_empty() { break }
        let sym = interner.get_or_intern(linet);
        if words.contains(&sym) {
            println!("String '{linet}' already interned as {sym:?}");
        } else {
            words.insert(sym);
            println!("'{linet}' = {sym:?}");
        }
    }

    println!("\n== Interned symbols ==");
    let mut syms = words.iter().collect::<Vec<_>>();
    syms.sort();
    for sym in syms {
        let s = interner.resolve(*sym).unwrap();
        println!("{sym:?} = '{s}'");
    }

    Ok(())
}

pub fn with_hasher(hasher: H) -> Self

where B: Default,

Create a new Interner with a default backend and the given hasher

pub fn with_backend(backend: B) -> Self

where H: Default,

Create a new Interner with a default hasher and the given backend

pub const fn with_backend_and_hasher(backend: B, hasher: H) -> Self

Create a new Interner with the given backend and hasher

pub fn get_or_intern<Ref>(&mut self, src: &Ref) -> B::Symbol

where Ref: Internable<T, B> + ?Sized + Hash + Eq, T: Borrow<Ref>,

Gets the Symbol for src, interning it if it doesn’t exist.

Example

use interns::Interner;

let mut interner = Interner::<str>::new();
let name = interner.get_or_intern("Abcd");
let name_again = interner.get_or_intern("Abcd");
assert_eq!(name, name_again);

Examples found in repository

examples/string.rs (line 19)

pub fn main() -> io::Result<()> {
    let mut interner: Interner<str> = Interner::new();

    let mut words = HashSet::new();
    let mut line = String::new();
    loop {
        line.clear();
        print!("> ");
        stdout().flush()?;

        stdin().read_line(&mut line)?;
        let linet = line.trim();
        if linet.is_empty() { break }
        let sym = interner.get_or_intern(linet);
        if words.contains(&sym) {
            println!("String '{linet}' already interned as {sym:?}");
        } else {
            words.insert(sym);
            println!("'{linet}' = {sym:?}");
        }
    }

    println!("\n== Interned symbols ==");
    let mut syms = words.iter().collect::<Vec<_>>();
    syms.sort();
    for sym in syms {
        let s = interner.resolve(*sym).unwrap();
        println!("{sym:?} = '{s}'");
    }

    Ok(())
}

pub fn resolve(&self, sym: B::Symbol) -> Option<&T>

Resolves the symbol into a reference of T

Example

use interns::Interner;

let mut interner = Interner::<str>::new();
let name = interner.get_or_intern("Abcd");
let resolved = interner.resolve(name);
assert_eq!(resolved, Some("Abcd"));

Examples found in repository

examples/string.rs (line 32)

pub fn main() -> io::Result<()> {
    let mut interner: Interner<str> = Interner::new();

    let mut words = HashSet::new();
    let mut line = String::new();
    loop {
        line.clear();
        print!("> ");
        stdout().flush()?;

        stdin().read_line(&mut line)?;
        let linet = line.trim();
        if linet.is_empty() { break }
        let sym = interner.get_or_intern(linet);
        if words.contains(&sym) {
            println!("String '{linet}' already interned as {sym:?}");
        } else {
            words.insert(sym);
            println!("'{linet}' = {sym:?}");
        }
    }

    println!("\n== Interned symbols ==");
    let mut syms = words.iter().collect::<Vec<_>>();
    syms.sort();
    for sym in syms {
        let s = interner.resolve(*sym).unwrap();
        println!("{sym:?} = '{s}'");
    }

    Ok(())
}

Trait Implementations

impl<T, B> Default for Interner<T, B>

where T: Hash + Eq + PartialEq + ?Sized, B: Backend<T> + Default,

fn default() -> Self

Returns the “default value” for a type.