Struct SemanticLexicon 

pub struct SemanticLexicon<'src, T: Eq, Category: Eq> { /* private fields */ }

A lexicon that is paired with semantic interpretations for its leaf nodes.

Each leaf must have a semantic interpretation defined as a [RootedLambdaPool<Expr>].

Implementations

impl<'src, T: Eq, C: Eq> SemanticLexicon<'src, T, C>

pub fn new( lexicon: Lexicon<T, C>, semantic_entries: HashMap<LexemeId, RootedLambdaPool<'src, Expr<'src>>>, ) -> Self

Create a new SemanticLexicon by combining a Lexicon and a [HashMap] of leaf nodes and semantic interpretations ([RootedLambdaPool])

impl<'src> SemanticLexicon<'src, &'src str, &'src str>

pub fn parse(s: &'src str) -> Result<Self, LambdaParseError>

Create a new semantic lexicon by parsing a string.

impl<'src, T: Eq + Clone + Debug, C: Eq + Clone + Debug> SemanticLexicon<'src, T, C>

pub fn interpretation( &self, lexeme_id: LexemeId, ) -> &RootedLambdaPool<'src, Expr<'src>>

Get the interpretation of a leaf node. Panics if the node has no semantic interpretation.

pub fn lexicon(&self) -> &Lexicon<T, C>

Get a reference to the underlying Lexicon

pub fn lexicon_mut(&mut self) -> &mut Lexicon<T, C>

Get a mutable reference to the underlying Lexicon

pub fn interpretations( &self, ) -> &HashMap<LexemeId, RootedLambdaPool<'src, Expr<'src>>>

Get a reference to the underlying [HashMap] of lexical entries.

pub fn interpretations_mut( &mut self, ) -> &mut HashMap<LexemeId, RootedLambdaPool<'src, Expr<'src>>>

Get a mutable reference to the underlying [HashMap] of lexical entries.

pub fn lexicon_and_interpretations_mut( &mut self, ) -> (&mut Lexicon<T, C>, &mut HashMap<LexemeId, RootedLambdaPool<'src, Expr<'src>>>)

Get a mutable reference to both the underlying Lexicon and [HashMap] of lexical entries.

pub fn remap_lexicon<T2: Eq, C2: Eq>( self, lemma_map: impl Fn(&T) -> T2, category_map: impl Fn(&C) -> C2, ) -> SemanticLexicon<'src, T2, C2>

Remaps the lexicon to a new category or lemma type

pub fn parse_and_interpret<'a, 'b: 'a>( &'a self, category: C, sentence: &'b [PhonContent<T>], config: &'b ParsingConfig, ) -> Result<impl Iterator<Item = (LogProb<f64>, &'a [PhonContent<T>], impl Iterator<Item = LanguageExpression<'src>>)>, ParsingError<C>>

Parse a sentence and return all its parses and their interpretations as nested iterators.

impl<'src, T: Eq + Debug + Clone, C: Eq + Debug + Clone + Display> SemanticLexicon<'src, T, C>

pub fn derivation( &self, rules: RulePool, h: SemanticHistory<'src>, ) -> Derivation<'src, T, C>

Converts a RulePool into a Derivation which allows the construction of Trees which can be used to plot syntactic trees throughout the derivation of the parse. This version allows for semantic information in the derivation as well.

Trait Implementations

impl<'src, T: Clone + Eq, Category: Clone + Eq> Clone for SemanticLexicon<'src, T, Category>

fn clone(&self) -> SemanticLexicon<'src, T, Category>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src, T: Debug + Eq, Category: Debug + Eq> Debug for SemanticLexicon<'src, T, Category>

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

Formats the value using the given formatter.

impl<T, C> Display for SemanticLexicon<'_, T, C>

where T: Eq + Display + Debug + Clone, C: Eq + Display + Debug + Clone,

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

Formats the value using the given formatter.

impl<T: Eq, C: Eq> From<SemanticLexicon<'_, T, C>> for Lexicon<T, C>

fn from(value: SemanticLexicon<'_, T, C>) -> Self

Converts to this type from the input type.

impl<'src, T: PartialEq + Eq, Category: PartialEq + Eq> PartialEq for SemanticLexicon<'src, T, Category>

fn eq(&self, other: &SemanticLexicon<'src, T, Category>) -> 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<'src, T: Eq + Eq, Category: Eq + Eq> Eq for SemanticLexicon<'src, T, Category>

impl<'src, T: Eq, Category: Eq> StructuralPartialEq for SemanticLexicon<'src, T, Category>