Struct Drs 

pub struct Drs { /* private fields */ }

Implementations

impl Drs

pub fn new() -> Drs

pub fn enter_box(&mut self, box_type: BoxType) -> usize

pub fn exit_box(&mut self)

pub fn current_box_index(&self) -> usize

pub fn current_box_type(&self) -> Option<BoxType>

pub fn introduce_referent( &mut self, variable: Symbol, noun_class: Symbol, gender: Gender, number: Number, )

pub fn introduce_referent_with_source( &mut self, variable: Symbol, noun_class: Symbol, gender: Gender, number: Number, source: ReferentSource, )

Introduce a referent with an explicit source (used for negative quantifiers like “No X”)

pub fn introduce_referent_with_modifiers( &mut self, variable: Symbol, noun_class: Symbol, gender: Gender, number: Number, source: ReferentSource, modifiers: Vec<Symbol>, )

Introduce a referent carrying its distinguishing modifier(s) (the adjective/gerund that does the referring in “the [modifier] [head]”). These modifiers feed context-driven coreference for definite descriptions — see Drs::resolve_definite_by_modifier.

pub fn introduce_referent_global( &mut self, variable: Symbol, noun_class: Symbol, gender: Gender, number: Number, source: ReferentSource, )

Accommodate a referent at the MAIN (highest) box. Definites presuppose existence, so they project globally even when first mentioned inside an embedded box (Van der Sandt global accommodation).

pub fn introduce_proper_name( &mut self, variable: Symbol, name: Symbol, gender: Gender, )

pub fn is_rigid_referent(&self, symbol: Symbol) -> bool

Is this symbol a RIGID referent (proper name or deictic constant)? A pronoun resolving to a rigid referent denotes the constant itself, not a discourse-bound variable.

pub fn register_item_category(&mut self, item: Symbol, category: Symbol)

Record that item was declared under category noun category. Called for each member of a coordinated category declaration; read back by a definite-description label to drive category-based un-fusing.

pub fn item_category(&self, item: Symbol) -> Option<Symbol>

The category noun item was declared under, if any.

pub fn is_accessible(&self, target_box: usize, from_box: usize) -> bool

Check if a referent in box from_box can access referents in box target_box

pub fn resolve_pronoun( &mut self, from_box: usize, gender: Gender, number: Number, ) -> Result<Symbol, ScopeError>

Resolve a pronoun by finding accessible referents matching gender and number

pub fn resolve_definite( &self, from_box: usize, noun_class: Symbol, ) -> Option<Symbol>

Resolve a definite description by finding accessible referent matching noun class

pub fn resolve_definite_by_modifier( &self, interner: &Interner, from_box: usize, noun_class: Symbol, modifiers: &[Symbol], ) -> Option<Symbol>

Context-driven coreference for MODIFIED definite descriptions.

When an exact head-noun match fails, two definite descriptions still corefer when (a) their distinguishing modifier matches AND (b) their head nouns are of a COMPATIBLE occasion sort. This is the modifier-does-the-referring principle: in “the hunting vacation” / “the hunting trip” the modifier Hunt identifies the entity and the head noun (vacation/trip) is a soft type, so both descriptions denote the same discourse referent.

This is NOT synonymy — no Vacation ↔ Trip axiom is asserted; the FOL keeps Vacation(x) and Trip(x) literally. Coreference is purely a referent-resolution step: the later description reuses the earlier referent’s variable.

Guardrails (enforced here):

• The modifier sets must match EXACTLY (differing modifiers — “the hunting trip” vs “the skydiving trip” — never corefer), and a bare (modifier-less) description never coreferes through this path.
• BOTH head nouns must be of an OCCASION sort (Sort::is_occasion) and mutually sort-compatible. Concrete objects (“the red box” / “the red ball”, both Physical) are excluded, so a shared modifier on non-occasion nouns never triggers coreference.

pub fn has_referent_by_variable(&self, var: Symbol) -> bool

Check if a referent exists by variable name (for imperative mode variable validation)

pub fn resolve_bridging( &self, interner: &Interner, noun_class: Symbol, ) -> Option<(Symbol, &'static str)>

Resolve bridging anaphora by finding referents whose type contains the noun as a part. Returns matching referent and whole name for PartOf relation.

pub fn get_universal_referents(&self) -> Vec<Symbol>

Get all referents that should receive universal quantification

pub fn get_existential_referents(&self) -> Vec<Symbol>

Get all referents that should receive existential quantification

pub fn get_last_event_referent(&self, interner: &Interner) -> Option<Symbol>

Get the most recent event referent (for binding weather adjectives to events)

pub fn in_conditional_antecedent(&self) -> bool

Check if we’re currently in a conditional antecedent

pub fn in_universal_restrictor(&self) -> bool

Check if we’re currently in a universal restrictor

pub fn get_telescope_candidates(&self) -> Vec<TelescopeCandidate>

Get all referents that can telescope across sentence boundaries. Only includes referents from boxes where can_telescope() is true. Excludes referents blocked by negation or disjunction.

pub fn find_blocked_referent( &self, from_box: usize, gender: Gender, ) -> Option<(Symbol, BoxType)>

Find a referent that matches but is blocked by scope. Used to generate informative error messages.

pub fn set_ownership(&mut self, noun_class: Symbol, state: OwnershipState)

Set ownership state for a referent by noun class

pub fn set_ownership_by_var(&mut self, var: Symbol, state: OwnershipState)

Set ownership state for a referent by variable name

pub fn get_ownership(&self, noun_class: Symbol) -> Option<OwnershipState>

Get ownership state for a referent by noun class

pub fn get_ownership_by_var(&self, var: Symbol) -> Option<OwnershipState>

Get ownership state for a referent by variable name

pub fn clear(&mut self)

Trait Implementations

impl Clone for Drs

fn clone(&self) -> Drs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Drs

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

Formats the value using the given formatter.

impl Default for Drs

fn default() -> Drs

Returns the “default value” for a type.