nibli_lexicon/

lib.rs

//! nibli-lexicon — the COMMITTED English corpus (the dictionary IS Rust source;
//! see [`corpus`] and the Dictionary Data section of CLAUDE.md).
//!
//! Since the committed-corpus milestone there is exactly ONE build mode: the
//! strongly-typed tables in `src/corpus/` are committed, const-validated at
//! compile time, and identical in local, CI, and deployed builds. The old
//! build-time parse of `dictionary-en.json` (and its FULL/FALLBACK dual mode)
//! is gone — the JSON is now only the INPUT of the `tools/lexigen` regeneration
//! tool (`just regen-lexicon`).
//!
//! The public surface is functions-only (no pub statics), so the internals can
//! evolve without consumer churn:
//! - [`alias`] / [`compound`] — KR-input resolution (English names / `a+b`
//!   compound spellings; gismu do NOT resolve — see the compat note below).
//! - [`get_arity`] / [`get_gloss`] / [`get_template`] — IR-relation lookups.
//! - [`canonical_alias`] / [`by_provenance`] — the gismu→English provenance
//!   bridge (Predilex gates, render overlays, lexigen drift reports).
//! - [`corpus::corpus_entries`] / [`corpus::corpus_compounds`] — iteration.
//!
//! Gismu do not resolve anywhere: the ONLY spellings are the English corpus
//! names (and `a+b` compound spellings). The source gismu survives solely as
//! the [`by_provenance`] bridge — provenance metadata, never input.

pub mod corpus;
pub mod reserved;

pub use corpus::{CompoundEntry, CorpusTier, PredicateEntry, Swap};

use std::collections::BTreeMap;
use std::sync::LazyLock;

/// Look up an English predicate name (the only resolvable atomic spelling).
/// `None` means the name is unknown — nibli-kr's resolver FAILS CLOSED (no
/// arity-2 default; NIBLI_KR §13).
pub fn alias(name: &str) -> Option<&'static PredicateEntry> {
    corpus::corpus_predicate(name)
}

/// Look up a compound predicate by its `a+b` KR spelling.
pub fn compound(spelling: &str) -> Option<&'static CompoundEntry> {
    corpus::corpus_compound(spelling)
}

/// Look up a compound by its IR RELATION ident (`computer_user`) — the
/// post-emit direction (render/arity/place-name lookups on compound
/// relations). Linear over the curated compound table, which stays small.
pub fn compound_by_relation(rel: &str) -> Option<&'static CompoundEntry> {
    corpus::corpus_compounds().find(|c| c.relation == rel)
}

/// English place names of an IR relation: an atomic corpus name or a
/// compound's relation ident. `None` = unknown relation (callers fall back
/// to positional `x<N>`).
pub fn relation_places(rel: &str) -> Option<&'static [&'static str]> {
    alias(rel)
        .map(|e| e.places)
        .or_else(|| compound_by_relation(rel).map(|c| c.places))
}

/// The provenance bridge: gismu → its CANONICAL (unswapped) corpus entry.
/// Permanent API — the Predilex gates key their Lojban-lemma bounds through it,
/// and future ontology-row import uses the same mapping.
pub fn by_provenance(gismu: &str) -> Option<&'static PredicateEntry> {
    static BY_PROVENANCE: LazyLock<BTreeMap<&'static str, &'static PredicateEntry>> =
        LazyLock::new(|| {
            corpus::corpus_entries()
                .filter(|e| e.swap.is_none())
                .map(|e| (e.source_gismu, e))
                .collect()
        });
    BY_PROVENANCE.get(gismu).copied()
}

/// The canonical (plain, unswapped) English name for a gismu — the render
/// direction. Converted entries are never canonical.
pub fn canonical_alias(gismu: &str) -> Option<&'static str> {
    by_provenance(gismu).map(|e| e.name)
}

/// Arity of an IR relation (English corpus name or compound relation ident).
pub fn get_arity(word: &str) -> Option<usize> {
    alias(word)
        .map(|e| e.arity() as usize)
        .or_else(|| compound_by_relation(word).map(|c| c.arity() as usize))
}

/// Primary English gloss of an IR relation.
pub fn get_gloss(word: &str) -> Option<&'static str> {
    alias(word)
        .map(|e| e.gloss)
        .or_else(|| compound_by_relation(word).map(|c| c.gloss))
}

/// Curated English place-frame template (`{x1}`..`{x5}` placeholders), e.g.
/// `get_template("dog")` -> `Some("{x1} is a dog")`. `None` = no curated frame;
/// callers build a generic frame from [`get_gloss`] + [`get_arity`].
pub fn get_template(word: &str) -> Option<&'static str> {
    alias(word)
        .map(|e| e.template)
        .or_else(|| compound_by_relation(word).map(|c| c.template))
        .flatten()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn english_lookups() {
        let goes = alias("goes").expect("goes");
        assert_eq!(goes.arity(), 5);
        assert_eq!(goes.source_gismu, "klama");
        assert_eq!(get_arity("goes"), Some(5));
        assert_eq!(get_arity("dog"), Some(2));
        assert_eq!(get_gloss("dog"), Some("dog"));
        assert_eq!(get_template("dog"), Some("{x1} is a dog"));
        assert_eq!(get_arity("quantity"), Some(3));
    }

    #[test]
    fn converted_entries_carry_their_base() {
        let owned = alias("owned").expect("owned");
        let swap = owned.swap.expect("owned is converted");
        assert_eq!(swap.with, 2);
        assert_eq!(swap.base, "owns");
        assert_eq!(owned.source_gismu, "ponse");
        // Canonical direction never returns a converted entry.
        assert_eq!(canonical_alias("ponse"), Some("owns"));
    }

    #[test]
    fn provenance_bridge() {
        assert_eq!(by_provenance("klama").map(|e| e.name), Some("goes"));
        assert_eq!(by_provenance("gerku").map(|e| e.name), Some("dog"));
        assert!(by_provenance("nosuchword").is_none());
    }

    #[test]
    fn gismu_never_resolve() {
        // GISMU-INPUT DEATH: raw gismu are provenance metadata, never input.
        assert_eq!(get_arity("klama"), None);
        assert_eq!(get_template("gerku"), None);
        assert!(alias("klama").is_none());
        // The bridge is the only gismu-keyed direction.
        assert_eq!(by_provenance("klama").map(|e| e.name), Some("goes"));
    }

    #[test]
    fn compounds_resolve_by_plus_spelling_only() {
        let cu = compound("computer+user").expect("seed compound");
        assert_eq!(cu.relation, "computer_user");
        assert_eq!(cu.arity(), 3);
        assert!(
            compound("dog+cat").is_none(),
            "undefined compounds fail closed"
        );
        assert!(
            alias("computer_user").is_none(),
            "the relation ident is not an input spelling"
        );
    }

    #[test]
    fn compound_relations_resolve_post_emit() {
        // The post-emit direction: the IR relation ident reaches the entry's
        // arity/gloss/places (render + semantics arity for compound relations).
        assert_eq!(
            compound_by_relation("computer_user").map(|c| c.name),
            Some("computer+user")
        );
        assert_eq!(get_arity("computer_user"), Some(3));
        assert!(get_gloss("computer_user").is_some());
        assert_eq!(relation_places("computer_user").map(|p| p[0]), Some("user"));
        assert_eq!(relation_places("dog").map(|p| p[0]), Some("dog"));
        assert!(relation_places("no_such_relation").is_none());
    }

    #[test]
    fn no_shipped_name_is_reserved() {
        for e in corpus::corpus_entries() {
            assert!(
                !reserved::is_reserved(e.name),
                "corpus name {:?} collides with a nibli KR keyword",
                e.name
            );
        }
    }

    #[test]
    fn every_place_is_named() {
        // The type makes this structural; assert the shipped data anyway.
        for e in corpus::corpus_entries() {
            assert!(!e.places.is_empty() && e.places.len() <= 5, "{:?}", e.name);
            for p in e.places {
                assert!(!p.is_empty(), "{:?} has an unnamed place", e.name);
            }
        }
    }
}