Struct Mention 

pub struct Mention {
    pub text: String,
    pub start: usize,
    pub end: usize,
    pub head_start: Option<usize>,
    pub head_end: Option<usize>,
    pub entity_type: Option<String>,
    pub mention_type: Option<MentionType>,
}

A single mention (text span) that may corefer with other mentions.

Mentions are comparable by span position, not by text content. Two mentions with identical text at different positions are distinct.

Character vs Byte Offsets

start and end are character offsets, not byte offsets. For “北京 Beijing”, the character offsets are:

• “北” = 0..1 (but 3 bytes in UTF-8)
• “京” = 1..2 (but 3 bytes)
• “ “ = 2..3
• “Beijing” = 3..10

Use text.chars().skip(start).take(end - start).collect() to extract.

Head Span

The head_start/head_end fields mark the syntactic head for head-match evaluation (used in CEAF-e, LEA metrics). In “the former president of France”, the head is “president” - the noun that determines agreement.

Fields

text: String

The mention text (surface form).

start: usize

Start character offset (inclusive, 0-indexed).

end: usize

End character offset (exclusive).

head_start: Option<usize>

Head word start (for head-match metrics like CEAF).

head_end: Option<usize>

Head word end.

entity_type: Option<String>

Entity type if known (e.g., “PER”, “ORG”).

mention_type: Option<MentionType>

Mention category: Pronominal, Proper, Nominal, Zero.

Implementations

impl Mention

pub fn new(text: impl Into<String>, start: usize, end: usize) -> Mention

Mention::new("John", 0, 4) creates a mention for “John” at characters 0..4.

Offsets are character positions, not byte positions.

pub fn with_head( text: impl Into<String>, start: usize, end: usize, head_start: usize, head_end: usize, ) -> Mention

Mention with head span for head-match evaluation.

The head is the syntactic nucleus: in “the former president”, head is “president”.

let m = Mention::with_head("the former president", 0, 20, 11, 20);
assert_eq!(m.head_start, Some(11)); // "president" starts at 11

pub fn with_type( text: impl Into<String>, start: usize, end: usize, mention_type: MentionType, ) -> Mention

Mention with type annotation for type-aware evaluation.

let pronoun = Mention::with_type("he", 25, 27, MentionType::Pronominal);
let proper = Mention::with_type("John Smith", 0, 10, MentionType::Proper);

pub fn overlaps(&self, other: &Mention) -> bool

True if spans share any characters: [0,5) overlaps [3,8).

pub fn span_matches(&self, other: &Mention) -> bool

True if spans are identical: same start AND end.

pub fn len(&self) -> usize

Span length in characters. Returns 0 if end <= start.

pub fn is_empty(&self) -> bool

True if span has zero length.

pub fn span_id(&self) -> (usize, usize)

(start, end) tuple for use in hash sets and comparisons.

Trait Implementations

impl Clone for Mention

fn clone(&self) -> Mention

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mention

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mention

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Mention

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

Formats the value using the given formatter.

impl From<&Entity> for Mention

fn from(entity: &Entity) -> Mention

Converts to this type from the input type.

impl From<&RankedMention> for Mention

Convert RankedMention to eval::coref::Mention for evaluation.

This enables using mention-ranking output directly in coreference evaluation.

fn from(mention: &RankedMention) -> Self

Converts to this type from the input type.

impl From<RankedMention> for Mention

fn from(mention: RankedMention) -> Self

Converts to this type from the input type.

impl Hash for Mention

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 Mention

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

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 Eq for Mention

impl StructuralPartialEq for Mention