Enum EntityType 

#[non_exhaustive]
pub enum EntityType {
    Person,
    Organization,
    Location,
    Date,
    Time,
    Money,
    Percent,
    Quantity,
    Cardinal,
    Ordinal,
    Email,
    Url,
    Phone,
    Custom {
        name: String,
        category: EntityCategory,
    },
    Other(String),
}

Entity type classification.

Organized into categories:

• Named (ML-required): Person, Organization, Location
• Temporal (pattern): Date, Time
• Numeric (pattern): Money, Percent, Quantity, Cardinal, Ordinal
• Contact (pattern): Email, Url, Phone

Examples

use anno_core::EntityType;

let ty = EntityType::Email;
assert!(ty.category().pattern_detectable());
assert!(!ty.category().requires_ml());

let ty = EntityType::Person;
assert!(ty.category().requires_ml());

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.

Person

Person name (PER) - requires ML/context

Organization

Organization name (ORG) - requires ML/context

Location

Location/Place (LOC/GPE) - requires ML/context

Date

Date expression (DATE) - pattern-detectable

Time

Time expression (TIME) - pattern-detectable

Money

Monetary value (MONEY) - pattern-detectable

Percent

Percentage (PERCENT) - pattern-detectable

Quantity

Quantity with unit (QUANTITY) - pattern-detectable

Cardinal

Cardinal number (CARDINAL) - pattern-detectable

Ordinal

Ordinal number (ORDINAL) - pattern-detectable

Email

Email address - pattern-detectable

Url

URL/URI - pattern-detectable

Phone

Phone number - pattern-detectable

Custom

Domain-specific custom type with explicit category

Fields

name: String

Type name (e.g., “DISEASE”, “PRODUCT”, “EVENT”)

category: EntityCategory

Category for this custom type

Other(String)

Legacy catch-all for unknown types (prefer Custom for new code)

Implementations

impl EntityType

pub fn category(&self) -> EntityCategory

Get the category of this entity type.

pub fn requires_ml(&self) -> bool

Returns true if this entity type requires ML for detection.

pub fn pattern_detectable(&self) -> bool

Returns true if this entity type can be detected via patterns.

pub fn as_label(&self) -> &str

Convert to standard label string (CoNLL/OntoNotes format).

pub fn from_label(label: &str) -> EntityType

Parse from standard label string.

Handles various formats: CoNLL (PER), OntoNotes (PERSON), BIO (B-PER).

pub fn custom(name: impl Into<String>, category: EntityCategory) -> EntityType

Create a custom domain-specific entity type.

Examples

use anno_core::{EntityType, EntityCategory};

// Medical entity - custom domain-specific type
let disease = EntityType::custom("DISEASE", EntityCategory::Agent);
assert!(disease.requires_ml());

// ID patterns - can be detected via patterns
let product_id = EntityType::custom("PRODUCT_ID", EntityCategory::Misc);

Trait Implementations

impl Clone for EntityType

fn clone(&self) -> EntityType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntityType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EntityType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EntityType

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

Formats the value using the given formatter.

impl From<EntityType> for TypeLabel

fn from(et: EntityType) -> TypeLabel

Converts to this type from the input type.

impl FromStr for EntityType

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

Parse from standard label string. Never fails - unknown labels become Other.

type Err = Infallible

The associated error which can be returned from parsing.

impl Hash for EntityType

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 EntityType

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

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 EntityType

impl StructuralPartialEq for EntityType