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,
    },
}

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

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).

use anno_core::EntityType;

assert_eq!(EntityType::Person.as_label(), "PER");
assert_eq!(EntityType::Location.as_label(), "LOC");

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

Parse from standard label string.

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

use anno_core::EntityType;

assert_eq!(EntityType::from_label("PER"), EntityType::Person);
assert_eq!(EntityType::from_label("B-ORG"), EntityType::Organization);
assert_eq!(EntityType::from_label("PERSON"), EntityType::Person);

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

Create a custom domain-specific entity type.

Examples

use anno_core::{EntityType, EntityCategory};

let disease = EntityType::custom("DISEASE", EntityCategory::Agent);
assert!(disease.requires_ml());

let product_id = EntityType::custom("PRODUCT_ID", EntityCategory::Misc);
assert!(!product_id.requires_ml());

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 Custom.

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