Enum MentionType 

pub enum MentionType {
    Proper,
    Nominal,
    Pronominal,
    Zero,
    Unknown,
}

Type of referring expression in coreference.

This classification is fundamental to coreference resolution:

• Proper nouns are typically antecedents (first mention)
• Nominal mentions provide descriptive information
• Pronominal mentions require resolution to an antecedent

Examples

use anno_core::types::MentionType;

let mention_type = MentionType::classify("John Smith");
assert_eq!(mention_type, MentionType::Proper);

let mention_type = MentionType::classify("the president");
assert_eq!(mention_type, MentionType::Nominal);

let mention_type = MentionType::classify("he");
assert_eq!(mention_type, MentionType::Pronominal);

Variants

Proper

Proper name (“John Smith”, “Microsoft”, “New York”)

Typically the first or canonical mention of an entity. Usually capitalized in English.

Also known as “Named” in NER terminology. Use MentionType::is_named() or the MentionType::NAMED constant for compatibility with code using that terminology.

Nominal

Common noun phrase (“the company”, “a dog”, “the president”)

Descriptive mentions that provide semantic information. May be definite (“the”) or indefinite (“a/an”).

Pronominal

Pronoun (“he”, “she”, “it”, “they”, “this”, “that”)

Anaphoric expressions that must be resolved to an antecedent. Includes personal, demonstrative, and relative pronouns.

Zero

Zero pronoun (pro-drop languages: Arabic, Spanish, Japanese, Korean, Chinese)

A dropped argument with no surface realization. The subject or object is grammatically required but omitted in the text. Common in:

• Arabic: verb conjugation encodes subject (“ذهب” = “[he] went”)
• Spanish: “Vino a casa” = “[He/She] came home”
• Japanese: topic/subject frequently omitted
• Chinese: arguments recoverable from context

Zero mentions have an anchor position (where they “would be”) but no text span. They carry phi-features (person, gender, number) from morphology or context.

Unknown

Unknown or unclassified mention type.

Implementations

impl MentionType

pub const NAMED: MentionType = MentionType::Proper

Alias for MentionType::Proper using NER terminology.

In NER, “named entity” is the standard term. In coreference literature, “proper noun/name” is preferred. Both refer to the same concept.

pub fn is_named(&self) -> bool

Check if this is a named/proper mention.

Returns true for MentionType::Proper. This is an alias using NER terminology for code that prefers “named” over “proper”.

pub fn classify(mention: &str) -> MentionType

Classify a mention string by its type.

Uses heuristics based on:

• Pronoun list matching
• Capitalization patterns
• Article presence

Examples

use anno_core::types::MentionType;

assert_eq!(MentionType::classify("Barack Obama"), MentionType::Proper);
assert_eq!(MentionType::classify("the former president"), MentionType::Nominal);
assert_eq!(MentionType::classify("he"), MentionType::Pronominal);

pub fn salience_weight(&self) -> f64

Get the typical salience weight for this mention type.

Proper nouns are most salient, pronouns and zeros least (they depend on context). Used in mention ranking algorithms.

pub fn can_introduce_entity(&self) -> bool

Check if this mention type typically introduces new entities.

Proper nouns often introduce entities; pronouns and zeros almost never do.

pub fn requires_antecedent(&self) -> bool

Check if this mention type requires an antecedent.

pub fn has_surface_form(&self) -> bool

Check if this mention type has a surface form in the text.

Returns false for zero pronouns (pro-drop).

pub fn is_zero(&self) -> bool

Check if this is a zero mention (pro-drop).

pub fn as_label(&self) -> &'static str

Get a string label for this mention type.

Returns a lowercase string suitable for use as a classification label.

Trait Implementations

impl Clone for MentionType

fn clone(&self) -> MentionType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MentionType

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

Formats the value using the given formatter.

impl Default for MentionType

fn default() -> MentionType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MentionType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MentionType

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

Formats the value using the given formatter.

impl FromStr for MentionType

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<MentionType, <MentionType as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for MentionType

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 Ord for MentionType

fn cmp(&self, other: &MentionType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for MentionType

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

Ordering for MentionType based on canonical selection priority.

Order: Zero < Pronominal < Unknown < Nominal < Proper

This ordering is useful for canonical mention selection: when choosing a representative mention from a cluster, higher-ranked types are preferred. Proper nouns are most informative, zeros are least.

fn partial_cmp(&self, other: &MentionType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for MentionType

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 Copy for MentionType

impl Eq for MentionType

impl StructuralPartialEq for MentionType