Enum ReferentType 

#[non_exhaustive]
pub enum ReferentType {
    Nominal,
    Event,
    Fact,
    Proposition,
    Situation,
    Manner,
    Segment,
}

Type of discourse referent (what kind of “thing” can be referred to).

Why This Taxonomy?

Not all things that can be referred to are “things” in the ordinary sense. When someone says “This surprised me,” the referent might be:

• A person (nominal) → standard coreference
• An event (“the crash”) → needs event extraction
• A fact (“that he won”) → needs propositional analysis
• A situation (“the ongoing crisis”) → needs discourse modeling

The type constrains what predicates are felicitous:

• Events can “happen,” “occur,” be “witnessed”
• Facts can be “known,” “believed,” “denied”
• Propositions can be “true,” “false,” “uncertain”

Research Background

This taxonomy follows Asher (1993) “Reference to Abstract Objects in Discourse” and Nedoluzhko & Lapshinova-Koltunski (2022) survey.

Ontological Distinctions

• Nominal: Standard NER entities (Person, Org, etc.)
• Event: Something that happened at a specific time/place
• Fact: A true proposition (can be asserted, denied)
• Proposition: A potential truth value (can be believed, doubted)
• Situation: A state of affairs (ongoing, not instantaneous)

Connection to Higher-Order Unification

When resolving anaphora to abstract referents, we solve P(source) = interpretation where the type of P is constrained by the referent type:

Referent Type	Property Domain	Example Predicate
Event	event → truth	“shocked everyone”
Fact	fact → truth	“is undeniable”
Proposition	prop → truth	“worries me”
Situation	situation → truth	“was unsustainable”

Shell nouns (see ShellNounClass) further constrain which referent types are valid—this acts as a type constraint on the unification variable.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Nominal

Standard nominal entity (Person, Org, Location)

Event

Event: happened at a specific time/place Example: “The earthquake struck” → EVENT

Fact

Fact: a true proposition that can be asserted Example: “Water boils at 100C” → FACT

Proposition

Proposition: a potential truth value Example: “She might resign” → PROPOSITION (not yet true/false)

Situation

Situation: ongoing state of affairs Example: “Prices are rising” → SITUATION

Manner

Manner: how something was done Example: “He spoke softly” → MANNER (the softness)

Segment

Discourse segment: a larger chunk of text Example: “The preceding paragraph” → SEGMENT

Implementations

impl ReferentType

pub const fn is_abstract(&self) -> bool

Is this an abstract (non-nominal) referent type?

pub const fn as_str(&self) -> &'static str

Human-readable label.

pub const fn can_be_this_antecedent(&self) -> bool

Can this referent type be the antecedent of “this”?

pub const fn can_be_it_antecedent(&self) -> bool

Can this referent type be the antecedent of “it”?

Trait Implementations

impl Clone for ReferentType

fn clone(&self) -> ReferentType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReferentType

impl Debug for ReferentType

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

Formats the value using the given formatter.

impl Default for ReferentType

fn default() -> ReferentType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReferentType

fn deserialize<__D>( __deserializer: __D, ) -> Result<ReferentType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReferentType

impl Hash for ReferentType

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ReferentType

fn eq(&self, other: &ReferentType) -> 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 Serialize for ReferentType

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ReferentType