Struct WordNet 

pub struct WordNet { /* private fields */ }

In-memory view of a WordNet dictionary backed by mmap or owned buffers.

Implementations

impl WordNet

pub fn load(dict_dir: impl AsRef<Path>) -> Result<Self>

Load WordNet from a directory containing data.* and index.* files.

Defaults to memory-mapping the source files. Use [load_with_mode] to force owned buffers instead.

pub fn load_with_mode( dict_dir: impl AsRef<Path>, mode: LoadMode, ) -> Result<Self>

Load WordNet choosing between mmap and owned buffers at runtime.

Examples found in repository

examples/stats.rs (line 14)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn lemma_exists(&self, pos: Pos, lemma: &str) -> bool

Check whether a lemma exists for the given POS according to index files.

Examples found in repository

examples/stats.rs (line 51)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn index_entry(&self, pos: Pos, lemma: &str) -> Option<IndexEntry<'_>>

Fetch a raw IndexEntry if present.

pub fn synsets_for_lemma(&self, pos: Pos, lemma: &str) -> &[SynsetId]

Return the synsets associated with a lemma, or an empty slice.

pub fn get_synset(&self, id: SynsetId) -> Option<Synset<'_>>

Fetch a Synset by id if loaded.

pub fn iter_synsets(&self) -> impl Iterator<Item = Synset<'_>> + '_

Iterate over all synsets as borrowed views.

Examples found in repository

examples/stats.rs (line 22)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn index_count(&self) -> usize

Number of index entries.

Examples found in repository

examples/stats.rs (line 32)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn lemma_count(&self) -> usize

Number of lemmas tracked across all parts of speech.

Examples found in repository

examples/stats.rs (line 33)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn synset_count(&self) -> usize

Number of synsets.

Examples found in repository

examples/stats.rs (line 34)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn verb_frame_templates_count(&self) -> usize

Number of verb frame template strings loaded.

Examples found in repository

examples/stats.rs (line 40)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn sense_count_entries(&self) -> usize

Number of sense-count entries parsed from cntlist.

Examples found in repository

examples/stats.rs (line 43)

fn main() -> Result<()> {
    let dict_dir = env::args()
        .nth(1)
        .map(PathBuf::from)
        .context("usage: cargo run -p wordnet-db --example stats -- <path-to-wordnet-dir>")?;

    let wn = WordNet::load_with_mode(&dict_dir, LoadMode::Mmap)
        .with_context(|| format!("loading WordNet from {}", dict_dir.display()))?;

    let mut word_count = 0usize;
    let mut pointer_count = 0usize;
    let mut gloss_example_count = 0usize;
    let mut verb_frame_instances = 0usize;

    for syn in wn.iter_synsets() {
        word_count += syn.words.len();
        pointer_count += syn.pointers.len();
        gloss_example_count += syn.gloss.examples.len();
        if syn.id.pos == Pos::Verb {
            verb_frame_instances += syn.frames.len();
        }
    }

    println!("Dictionary: {}", dict_dir.display());
    println!("Index entries: {}", wn.index_count());
    println!("Lemma keys   : {}", wn.lemma_count());
    println!("Synsets      : {}", wn.synset_count());
    println!("Words in synsets: {}", word_count);
    println!("Pointers     : {}", pointer_count);
    println!("Gloss examples: {}", gloss_example_count);
    println!(
        "Verb frame templates (frames.vrb): {}",
        wn.verb_frame_templates_count()
    );
    println!("Verb frame instances in synsets: {}", verb_frame_instances);
    println!("Sense-count entries: {}", wn.sense_count_entries());

    // Spot-check a couple of lemmas to confirm lookup.
    for (pos, lemma) in [(Pos::Noun, "dog"), (Pos::Verb, "run")] {
        println!(
            "Lemma '{}' ({:?}) exists? {}",
            lemma,
            pos,
            wn.lemma_exists(pos, lemma)
        );
    }

    Ok(())
}

pub fn sense_count( &self, pos: Pos, lemma: &str, synset_offset: u32, ) -> Option<u32>

Sense frequency for a given lemma/pos/synset, if present in cntlist.rev.