Struct PhiFeatures 

pub struct PhiFeatures {
    pub person: Person,
    pub number: Number,
    pub gender: Gender,
}

A bundle of phi-features (person, number, gender) for morphological agreement.

This struct packages the three core phi-features into a single unit that can be attached to mentions (especially zero mentions) and used for coreference constraint checking.

Use Cases

1. Zero pronoun representation: When Arabic “ذهب” (dhahaba, “he went”) drops its subject, we create a zero mention with PhiFeatures::third_sg_masc().

2. Coreference filtering: Two mentions can only corefer if their phi-features are compatible. “John… she” fails the gender check.

3. Factor graph constraints: In joint entity models, phi-feature compatibility can be a soft factor between mention pairs.

Example: Arabic Zero Pronoun Resolution

use anno_core::types::{PhiFeatures, Person, Number, Gender};

// Arabic verb "كَتَبَتْ" (katabat) = "[she] wrote"
// The -at suffix encodes: 3rd person, singular, feminine
let verb_features = PhiFeatures::new(
    Person::Third,
    Number::Singular,
    Gender::Feminine
);

// Candidate antecedent: "مريم" (Maryam, a feminine name)
let maryam_features = PhiFeatures::new(
    Person::Third,
    Number::Singular,
    Gender::Feminine
);

// Candidate antecedent: "أحمد" (Ahmad, a masculine name)
let ahmad_features = PhiFeatures::third_sg_masc();

// Maryam is compatible (same features), Ahmad is not (gender mismatch)
assert!(verb_features.is_compatible(&maryam_features));
assert!(!verb_features.is_compatible(&ahmad_features));

Parsing from Strings

Phi-features can be parsed from compact notation:

use anno_core::types::PhiFeatures;

let phi = PhiFeatures::parse("3sgm").unwrap();  // 3rd singular masculine
let phi = PhiFeatures::parse("1plf").unwrap();  // 1st plural feminine
let phi = PhiFeatures::parse("2du").unwrap();   // 2nd dual (gender unspecified)

Fields

person: Person

Grammatical person (1st/2nd/3rd)

Indicates the discourse role: speaker, listener, or other.

number: Number

Grammatical number (singular/dual/plural)

Indicates quantity. Languages like Arabic distinguish dual from plural.

gender: Gender

Grammatical gender (masculine/feminine/neutral)

In languages like Arabic, gender is grammatically assigned to all nouns, not just animate entities.

Implementations

impl PhiFeatures

pub fn new(person: Person, number: Number, gender: Gender) -> PhiFeatures

Create a new phi-features bundle with explicit values.

Example

use anno_core::types::{PhiFeatures, Person, Number, Gender};

// Spanish "Vino" = "[He/She] came" - 3rd singular, gender unknown
let phi = PhiFeatures::new(Person::Third, Number::Singular, Gender::Unknown);

pub fn third_sg_masc() -> PhiFeatures

Create 3rd person singular masculine.

This is the most common phi-feature combination for zero pronouns in Arabic narrative text, where the default subject is often a previously mentioned male character.

Example

use anno_core::types::PhiFeatures;

// Arabic "ذَهَبَ" (dhahaba) = "[he] went"
let phi = PhiFeatures::third_sg_masc();

pub fn third_sg_fem() -> PhiFeatures

Create 3rd person singular feminine.

Used for verbs with feminine subject agreement.

Example

use anno_core::types::PhiFeatures;

// Arabic "ذَهَبَتْ" (dhahabat) = "[she] went" - note the -t suffix
let phi = PhiFeatures::third_sg_fem();

pub fn third_plural() -> PhiFeatures

Create 3rd person plural with neutral/unspecified gender.

In Arabic, plural verbs can use masculine or feminine forms depending on the referent. This constructor uses neutral for cases where gender is not recoverable from morphology.

Example

use anno_core::types::PhiFeatures;

// Spanish "Vinieron" = "[They] came" - plural, gender unspecified
let phi = PhiFeatures::third_plural();

pub fn is_compatible(&self, other: &PhiFeatures) -> bool

Check if these phi-features are compatible with another set.

Compatibility is checked per-feature:

• Person must match exactly
• Number allows dual↔plural (since pairs can be referred to as plural)
• Gender uses the rules from Gender::is_compatible

This is a soft constraint for coreference: incompatible phi-features make coreference unlikely but not impossible (errors, metaphor, etc.).

Example

use anno_core::types::PhiFeatures;

let he = PhiFeatures::third_sg_masc();
let she = PhiFeatures::third_sg_fem();
let they = PhiFeatures::third_plural();

assert!(!he.is_compatible(&she));  // Gender mismatch
assert!(!he.is_compatible(&they)); // Number mismatch

pub fn parse(s: &str) -> Option<PhiFeatures>

Parse phi-features from a compact string notation.

Accepts formats like:

• "3sgm" - 3rd singular masculine
• "1plf" - 1st plural feminine
• "2du" - 2nd dual (gender unspecified)

Returns None if the string cannot be parsed.

Example

use anno_core::types::{PhiFeatures, Person, Number, Gender};

let phi = PhiFeatures::parse("3sgm").unwrap();
assert_eq!(phi.person, Person::Third);
assert_eq!(phi.number, Number::Singular);
assert_eq!(phi.gender, Gender::Masculine);

Trait Implementations

impl Clone for PhiFeatures

fn clone(&self) -> PhiFeatures

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhiFeatures

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

Formats the value using the given formatter.

impl Default for PhiFeatures

fn default() -> PhiFeatures

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PhiFeatures

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PhiFeatures

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

Formats the value using the given formatter.

impl Hash for PhiFeatures

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 PhiFeatures

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

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 PhiFeatures

impl Eq for PhiFeatures

impl StructuralPartialEq for PhiFeatures