Struct AstContext 

pub struct AstContext<'a> {
    pub exprs: &'a Arena<LogicExpr<'a>>,
    pub terms: &'a Arena<Term<'a>>,
    pub nps: &'a Arena<NounPhrase<'a>>,
    pub syms: &'a Arena<Symbol>,
    pub roles: &'a Arena<(ThematicRole, Term<'a>)>,
    pub pps: &'a Arena<&'a LogicExpr<'a>>,
    pub stmts: Option<&'a Arena<Stmt<'a>>>,
    pub imperative_exprs: Option<&'a Arena<Expr<'a>>>,
    pub type_exprs: Option<&'a Arena<TypeExpr<'a>>>,
}

Collection of typed arenas for AST allocation during parsing.

The context holds references to multiple arenas, each specialized for a particular AST node type. This separation allows efficient allocation while maintaining type safety.

Modes

The context supports two modes:

• Declarative (default): For natural language parsing to logic
• Imperative: Adds statement and expression arenas for LOGOS programs

Fields

exprs: &'a Arena<LogicExpr<'a>>

Arena for logical expressions (LogicExpr).

terms: &'a Arena<Term<'a>>

Arena for first-order terms (Term).

nps: &'a Arena<NounPhrase<'a>>

Arena for noun phrases (NounPhrase).

syms: &'a Arena<Symbol>

Arena for interned symbols.

roles: &'a Arena<(ThematicRole, Term<'a>)>

Arena for thematic role assignments.

pps: &'a Arena<&'a LogicExpr<'a>>

Arena for prepositional phrase modifiers.

stmts: Option<&'a Arena<Stmt<'a>>>

Optional arena for imperative statements (LOGOS mode).

imperative_exprs: Option<&'a Arena<Expr<'a>>>

Optional arena for imperative expressions (LOGOS mode).

type_exprs: Option<&'a Arena<TypeExpr<'a>>>

Optional arena for type expressions (LOGOS mode).

Implementations

impl<'a> AstContext<'a>

pub fn new( exprs: &'a Arena<LogicExpr<'a>>, terms: &'a Arena<Term<'a>>, nps: &'a Arena<NounPhrase<'a>>, syms: &'a Arena<Symbol>, roles: &'a Arena<(ThematicRole, Term<'a>)>, pps: &'a Arena<&'a LogicExpr<'a>>, ) -> Self

Creates a new context for declarative (natural language) parsing.

pub fn with_imperative( exprs: &'a Arena<LogicExpr<'a>>, terms: &'a Arena<Term<'a>>, nps: &'a Arena<NounPhrase<'a>>, syms: &'a Arena<Symbol>, roles: &'a Arena<(ThematicRole, Term<'a>)>, pps: &'a Arena<&'a LogicExpr<'a>>, stmts: &'a Arena<Stmt<'a>>, imperative_exprs: &'a Arena<Expr<'a>>, ) -> Self

Creates a context with imperative statement arenas for LOGOS programs.

pub fn with_types( exprs: &'a Arena<LogicExpr<'a>>, terms: &'a Arena<Term<'a>>, nps: &'a Arena<NounPhrase<'a>>, syms: &'a Arena<Symbol>, roles: &'a Arena<(ThematicRole, Term<'a>)>, pps: &'a Arena<&'a LogicExpr<'a>>, stmts: &'a Arena<Stmt<'a>>, imperative_exprs: &'a Arena<Expr<'a>>, type_exprs: &'a Arena<TypeExpr<'a>>, ) -> Self

Creates a context with type expression arena for typed LOGOS programs.

pub fn alloc_stmt(&self, stmt: Stmt<'a>) -> &'a Stmt<'a>

Allocates an imperative statement.

Panics

Panics if imperative arenas were not initialized.

pub fn alloc_imperative_expr(&self, expr: Expr<'a>) -> &'a Expr<'a>

Allocates an imperative expression.

Panics

Panics if imperative arenas were not initialized.

pub fn alloc_type_expr(&self, ty: TypeExpr<'a>) -> &'a TypeExpr<'a>

Allocates a type expression.

Panics

Panics if type expression arena was not initialized.

pub fn alloc_type_exprs<I>(&self, types: I) -> &'a [TypeExpr<'a>]

where I: IntoIterator<Item = TypeExpr<'a>>, I::IntoIter: ExactSizeIterator,

Allocates a slice of type expressions.

Panics

Panics if type expression arena was not initialized.

pub fn alloc_expr(&self, expr: LogicExpr<'a>) -> &'a LogicExpr<'a>

Allocates a logical expression.

pub fn alloc_term(&self, term: Term<'a>) -> &'a Term<'a>

Allocates a first-order term.

pub fn alloc_terms<I>(&self, terms: I) -> &'a [Term<'a>]

where I: IntoIterator<Item = Term<'a>>, I::IntoIter: ExactSizeIterator,

Allocates a slice of terms from an iterator.

pub fn alloc_np(&self, np: NounPhrase<'a>) -> &'a NounPhrase<'a>

Allocates a noun phrase.

pub fn alloc_syms<I>(&self, syms: I) -> &'a [Symbol]

where I: IntoIterator<Item = Symbol>, I::IntoIter: ExactSizeIterator,

Allocates a slice of symbols from an iterator.

pub fn alloc_roles<I>(&self, roles: I) -> &'a [(ThematicRole, Term<'a>)]

where I: IntoIterator<Item = (ThematicRole, Term<'a>)>, I::IntoIter: ExactSizeIterator,

Allocates a slice of thematic role assignments.

pub fn alloc_pps<I>(&self, pps: I) -> &'a [&'a LogicExpr<'a>]

where I: IntoIterator<Item = &'a LogicExpr<'a>>, I::IntoIter: ExactSizeIterator,

Allocates a slice of prepositional phrase modifiers.

pub fn predicate(&self, name: Symbol, args: &'a [Term<'a>]) -> &'a LogicExpr<'a>

Creates an atomic predicate: P(t1, t2, ...).

pub fn binary( &self, left: &'a LogicExpr<'a>, op: TokenType, right: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates a binary operation: left op right.

pub fn unary( &self, op: TokenType, operand: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates a unary operation: op operand.

pub fn quantifier( &self, kind: QuantifierKind, variable: Symbol, body: &'a LogicExpr<'a>, island_id: u32, ) -> &'a LogicExpr<'a>

Creates a quantified formula: ∀x.body or ∃x.body.

pub fn temporal( &self, operator: TemporalOperator, body: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates a temporal operator: PAST(body) or FUTURE(body).

pub fn aspectual( &self, operator: AspectOperator, body: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates an aspectual operator: PROG(body), PERF(body), etc.

pub fn voice( &self, operator: VoiceOperator, body: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates a voice operator: PASSIVE(body).

pub fn modal( &self, vector: ModalVector, operand: &'a LogicExpr<'a>, ) -> &'a LogicExpr<'a>

Creates a modal operator: □operand or ◇operand.

Trait Implementations

impl<'a> Clone for AstContext<'a>

fn clone(&self) -> AstContext<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for AstContext<'a>