Struct ParserGuard 

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

RAII guard for speculative parsing with automatic rollback.

Created by Parser::guard(), this guard saves the parser state on creation and automatically restores it if the guard is dropped without being committed.

Usage

let mut guard = parser.guard();
if let Ok(result) = try_parse(&mut *guard) {
    guard.commit(); // Success - keep changes
    return Ok(result);
}
// guard dropped here - parser state restored

Implementations

impl<'p, 'a, 'ctx, 'int> ParserGuard<'p, 'a, 'ctx, 'int>

pub fn commit(self)

Commits the parse, preventing rollback when the guard is dropped.

Methods from Deref<Target = Parser<'a, 'ctx, 'int>>

pub fn stmt_spans(&self) -> &[Span]

The span of each top-level statement from the last parse_program call, aligned 1:1 with the returned statement list.

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_distributive_marker(&mut self, on: bool)

Force the distributive (per-member) reading of mixed verbs with definite plurals — the readings enumerator’s counterpart to the default collective reading.

pub fn set_pragmatic_mode(&mut self, on: bool)

Enable pragmatic enrichment (scalar implicatures, degree standards) for whole-program parses — the defeasible theorem door needs the implicature channel that the literal parse omits.

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_pragmatic(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>

Parses with pragmatic enrichment: the truth-conditional parse PLUS scalar implicature (§8.7). The literal parse() is unchanged; here a leading weak scalar “some” is strengthened to ∃… +> ¬∀…. Used by the pragmatic compile path so the implicature appears as a separate labeled component.

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

pub fn program_opt_flags(&self) -> OptimizationConfig

The program-wide optimization config from file-level ## No <X> decorators (all-on minus the file-level disables). The compile entry combines this with from_env and per-function flags.

pub fn program_tier_pins(&self) -> PinSet

The program-wide tiered-optimizer pins from file-level ## Tier <opt> <value> decorators (HOTSWAP §8). The run-path engine overlays these onto the env crate::optimization::HotswapConfig before optimizing.

Trait Implementations

impl<'p, 'a, 'ctx, 'int> Deref for ParserGuard<'p, 'a, 'ctx, 'int>

type Target = Parser<'a, 'ctx, 'int>

The resulting type after dereferencing.

fn deref(&self) -> &<ParserGuard<'p, 'a, 'ctx, 'int> as Deref>::Target

Dereferences the value.

impl<'p, 'a, 'ctx, 'int> DerefMut for ParserGuard<'p, 'a, 'ctx, 'int>

fn deref_mut( &mut self, ) -> &mut <ParserGuard<'p, 'a, 'ctx, 'int> as Deref>::Target

Mutably dereferences the value.

impl<'p, 'a, 'ctx, 'int> Drop for ParserGuard<'p, 'a, 'ctx, 'int>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.