Struct Parser 

pub struct Parser<'a, 'ctx, 'int> { /* private fields */ }

Recursive descent parser for natural language to first-order logic.

The parser transforms a token stream (from Lexer) into logical expressions (LogicExpr). It handles complex linguistic phenomena including:

• Quantifier scope ambiguity
• Pronoun resolution via DRS
• Modal verb interpretation
• Temporal and aspectual marking
• VP ellipsis resolution

Lifetimes

• 'a: Arena lifetime for allocated AST nodes
• 'ctx: WorldState lifetime for discourse tracking
• 'int: Interner lifetime for symbol management

Implementations

impl<'a, 'ctx, 'int> Parser<'a, 'ctx, 'int>

pub fn new( tokens: Vec<Token>, world_state: &'ctx mut WorldState, interner: &'int mut Interner, ctx: AstContext<'a>, types: TypeRegistry, ) -> Self

Create a parser with WorldState for discourse-level parsing. WorldState is REQUIRED - there is no “single sentence mode”. A single sentence is just a discourse of length 1.

pub fn set_discourse_event_var(&mut self, var: Symbol)

pub fn drs_mut(&mut self) -> &mut Drs

Get mutable reference to the active DRS (from WorldState).

pub fn drs_ref(&self) -> &Drs

Get immutable reference to the active DRS (from WorldState).

pub fn swap_drs_with_world_state(&mut self)

Swap DRS between Parser and WorldState. Call at start of parsing to get the accumulated DRS from WorldState. Call at end of parsing to save the updated DRS back to WorldState.

pub fn has_world_state(&self) -> bool

WorldState is always present (no “single sentence mode”)

pub fn mode(&self) -> ParserMode

pub fn is_known_type(&self, sym: Symbol) -> bool

Check if a symbol is a known type in the registry. Used to disambiguate “Stack of Integers” (generic type) vs “Owner of House” (possessive).

pub fn is_generic_type(&self, sym: Symbol) -> bool

Check if a symbol is a known generic type (takes type parameters). Used to parse “Stack of Integers” as generic instantiation.

pub fn process_block_headers(&mut self)

pub fn get_event_var(&mut self) -> Symbol

pub fn capture_event_template( &mut self, verb: Symbol, roles: &[(ThematicRole, Term<'a>)], modifiers: &[Symbol], )

pub fn set_pp_attachment_mode(&mut self, attach_to_noun: bool)

pub fn set_noun_priority_mode(&mut self, mode: bool)

pub fn set_collective_mode(&mut self, mode: bool)

pub fn set_event_reading_mode(&mut self, mode: bool)

pub fn set_negative_scope_mode(&mut self, mode: NegativeScopeMode)

pub fn set_modal_preference(&mut self, pref: ModalPreference)

pub fn guard(&mut self) -> ParserGuard<'_, 'a, 'ctx, 'int>

pub fn parse(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses the token stream into a logical expression.

This is the main entry point for declarative/FOL parsing. It handles multi-sentence inputs by conjoining them with logical AND, and processes various sentence types including declaratives, questions, and imperatives.

Returns

An arena-allocated LogicExpr representing the parsed input, or a ParseError with source location and Socratic explanation.

Discourse State

The parser maintains discourse state across sentences, enabling anaphora resolution (“he”, “she”, “they” refer to prior entities) and temporal coherence (tense interpretation relative to reference time).

pub fn parse_program(&mut self) -> Result<Vec<Stmt<'a>>, ParseError>

Parses a LOGOS program into a list of statements.

This is the main entry point for imperative/executable LOGOS code. It handles block structures (Definition, Policy, Procedure, Theorem), function definitions, type definitions, and executable statements.

Returns

A vector of arena-allocated Stmt representing the program, or a ParseError with source location and Socratic explanation.

Block Types

• Definition: Type definitions (structs, enums, generics)
• Policy: Security predicates and capability rules
• Procedure: Executable code blocks
• Theorem: Logical propositions with proof strategies

Trait Implementations

impl<'a, 'ctx, 'int> ClauseParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_either_or(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parse “Either NP1 or NP2 is/are PRED” or “Either S1 or S2”

Handles coordination: “Either Alice or Bob is guilty” should become guilty(Alice) ∨ guilty(Bob), not Alice ∨ guilty(Bob)

fn parse_gapped_clause( &mut self, borrowed_verb: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Phase 46: Generalized gapping with template-guided reconstruction. Handles NPs, PPs, temporal adverbs, and preserves roles from EventTemplate.

fn parse_disjunction(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parse disjunction (Or/Iff) - lowest precedence logical connectives. Calls parse_conjunction for operands to ensure And binds tighter.

fn parse_conjunction(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parse conjunction (And) - higher precedence than Or. Calls parse_atom for operands.

fn parse_sentence(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a complete sentence, handling imperatives, ellipsis, and questions.

fn check_wh_word(&self) -> bool

Checks if current token is a wh-word (who, what, which, etc.).

fn parse_conditional(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses “if P then Q” conditionals with DRS scope handling.

fn is_counterfactual_context(&self) -> bool

Returns true if parsing a counterfactual context.

fn parse_counterfactual_antecedent( &mut self, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses “if P were/had” counterfactual antecedent (subjunctive).

fn parse_counterfactual_consequent( &mut self, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses “Q would” counterfactual consequent.

fn extract_verb_from_expr(&self, expr: &LogicExpr<'a>) -> Option<Symbol>

Extracts the main verb from an expression.

fn is_complete_clause(&self, expr: &LogicExpr<'a>) -> bool

Returns true if expression is a complete clause.

fn parse_relative_clause( &mut self, gap_var: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses “who/that/which” relative clauses attaching to noun phrases.

fn check_ellipsis_auxiliary(&self) -> bool

Checks for ellipsis auxiliary (did, does, can, etc.).

fn check_ellipsis_terminator(&self) -> bool

Checks for ellipsis terminator (too, also, as well).

fn try_parse_ellipsis( &mut self, ) -> Option<Result<&'a LogicExpr<'a>, ParseError>>

Attempts to parse VP ellipsis (“Mary did too”).

impl<'a, 'ctx, 'int> LogicVerbParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn build_group_predicate( &mut self, subjects: &[Symbol], verb: Symbol, verb_time: Time, ) -> &'a LogicExpr<'a>

Build a group predicate for intransitive verbs

fn build_group_transitive( &mut self, subjects: &[Symbol], objects: &[Symbol], verb: Symbol, verb_time: Time, ) -> &'a LogicExpr<'a>

Build a transitive predicate with group subject and group object

fn parse_predicate_with_subject( &mut self, subject_symbol: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a verb phrase given the subject as a constant symbol.

fn parse_predicate_with_subject_as_var( &mut self, subject_symbol: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a verb phrase with subject as a bound variable.

fn try_parse_plural_subject( &mut self, first_subject: &NounPhrase<'a>, ) -> Result<Option<&'a LogicExpr<'a>>, ParseError>

Attempts to parse a plural subject (“John and Mary verb”). Returns Ok(Some(expr)) on success, Ok(None) if not plural, Err on semantic error.

fn parse_control_structure( &mut self, subject: &NounPhrase<'a>, verb: Symbol, verb_time: Time, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses control verb structures: “wants to VP”, “persuaded X to VP”.

fn is_control_verb(&self, verb: Symbol) -> bool

Checks if a verb is a control verb (want, try, persuade, etc.).

impl<'a, 'ctx, 'int> ModalParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_modal(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a modal verb and its scope content.

fn parse_aspect_chain( &mut self, subject_symbol: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses perfect/progressive aspect chain with a symbol subject.

fn parse_aspect_chain_with_term( &mut self, subject_term: Term<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses perfect/progressive aspect chain with a term subject.

fn token_to_vector(&self, token: &TokenType) -> ModalVector

Converts a modal token to its semantic vector (domain, force, flavor).

impl<'a, 'ctx, 'int> NounParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_noun_phrase( &mut self, greedy: bool, ) -> Result<NounPhrase<'a>, ParseError>

Parses a full noun phrase with optional greedy PP attachment.

fn parse_noun_phrase_for_relative( &mut self, ) -> Result<NounPhrase<'a>, ParseError>

Parses a noun phrase suitable for relative clause antecedent.

fn noun_phrase_to_term(&self, np: &NounPhrase<'a>) -> Term<'a>

Converts a parsed noun phrase to a first-order term.

fn check_possessive(&self) -> bool

Checks for possessive marker (’s).

fn check_of_preposition(&self) -> bool

Checks for “of” preposition (possessive or partitive).

fn check_proper_name_or_label(&self) -> bool

Checks for proper name or label (capitalized).

fn check_possessive_pronoun(&self) -> bool

Checks for possessive pronoun (his, her, its, their).

impl<'a, 'ctx, 'int> PragmaticsParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_focus(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a focus particle construction: “only John runs”, “even Mary left”.

fn parse_measure(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a measure construction: “much water is cold”, “little food arrived”.

fn parse_presupposition( &mut self, subject: &NounPhrase<'a>, presup_kind: PresupKind, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a presupposition-triggering verb: “stopped running”, “regrets leaving”.

fn parse_predicate_for_subject( &mut self, subject: &NounPhrase<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a simple predicate for a given subject noun phrase.

fn parse_scopal_adverb( &mut self, subject: &NounPhrase<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a scopal adverb construction: “always runs”, “never sleeps”.

fn parse_superlative( &mut self, subject: &NounPhrase<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a superlative construction: “is the tallest student”.

fn parse_comparative( &mut self, subject: &NounPhrase<'a>, _copula_time: Time, difference: Option<&'a Term<'a>>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a comparative construction: “is taller than Mary”, “is greater than 0”.

fn check_number(&self) -> bool

Checks if the current token is a numeric literal.

fn parse_measure_phrase(&mut self) -> Result<&'a Term<'a>, ParseError>

Parses a measure phrase: “5 meters”, “100 kilograms”.

impl<'a, 'ctx, 'int> QuantifierParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_quantified(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a quantified expression from a quantifier determiner.

fn parse_restriction( &mut self, var_name: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses the restrictor clause for a quantifier.

fn parse_verb_phrase_for_restriction( &mut self, var_name: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a verb phrase as the nuclear scope of a quantifier.

fn combine_with_and( &self, exprs: Vec<&'a LogicExpr<'a>>, ) -> Result<&'a LogicExpr<'a>, ParseError>

Combines multiple expressions with conjunction.

fn wrap_with_definiteness_full( &mut self, np: &NounPhrase<'a>, predicate: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn wrap_with_definiteness( &mut self, definiteness: Option<Definiteness>, noun: Symbol, predicate: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn wrap_with_definiteness_and_adjectives( &mut self, definiteness: Option<Definiteness>, noun: Symbol, adjectives: &[Symbol], predicate: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn wrap_with_definiteness_and_adjectives_and_pps( &mut self, definiteness: Option<Definiteness>, noun: Symbol, adjectives: &[Symbol], pps: &[&'a LogicExpr<'a>], predicate: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn wrap_with_definiteness_for_object( &mut self, definiteness: Option<Definiteness>, noun: Symbol, predicate: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn substitute_pp_placeholder( &mut self, pp: &'a LogicExpr<'a>, var: Symbol, ) -> &'a LogicExpr<'a>

fn substitute_constant_with_var( &self, expr: &'a LogicExpr<'a>, constant_name: Symbol, var_name: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn substitute_constant_with_var_sym( &self, expr: &'a LogicExpr<'a>, constant_name: Symbol, var_name: Symbol, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn substitute_constant_with_sigma( &self, expr: &'a LogicExpr<'a>, constant_name: Symbol, sigma_term: Term<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn find_main_verb_name(&self, expr: &LogicExpr<'a>) -> Option<Symbol>

fn transform_cardinal_to_group( &mut self, expr: &'a LogicExpr<'a>, ) -> Result<&'a LogicExpr<'a>, ParseError>

fn build_verb_neo_event( &mut self, verb: Symbol, subject_var: Symbol, object: Option<Term<'a>>, modifiers: Vec<Symbol>, ) -> &'a LogicExpr<'a>

impl<'a, 'ctx, 'int> QuestionParsing<'a, 'ctx, 'int> for Parser<'a, 'ctx, 'int>

fn parse_wh_question(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a wh-question: “Who runs?”, “What does John love?”.

fn parse_yes_no_question(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses a yes/no question: “Does John run?”, “Is Mary tall?”.

fn aux_token_to_modal_vector(&self, token: &TokenType) -> ModalVector

Converts an auxiliary token to its modal vector for questions.