Enum Sort 

pub enum Sort {
    Entity,
    Physical,
    Animate,
    Human,
    Plant,
    Place,
    Time,
    Abstract,
    Information,
    Event,
    Celestial,
    Value,
    Signal,
    Group,
}

Semantic sorts for type checking.

Variants

Entity

Top of the hierarchy; any individual.

Physical

Concrete, spatially located objects.

Animate

Living beings capable of self-motion.

Human

Persons with intentional agency.

Plant

Non-animal living organisms.

Place

Locations and regions.

Time

Temporal intervals and points.

Abstract

Non-physical, conceptual entities.

Information

Propositional content and data.

Event

Occurrences and happenings.

Celestial

Stars, planets, and astronomical bodies.

Value

Numeric or monetary amounts.

Signal

Hardware signals, wires, clocks, and buses.

Group

Collections of individuals.

Implementations

impl Sort

pub fn is_compatible_with(self, other: Sort) -> bool

Check if this sort can be used where other is expected.

Sort compatibility follows a subsumption hierarchy:

• Human ⊆ Animate ⊆ Physical ⊆ Entity
• Plant ⊆ Animate ⊆ Physical ⊆ Entity
• Everything ⊆ Entity

For example, a Human noun can fill an Animate slot, but not vice versa.

pub fn is_occasion(self) -> bool

Whether this sort denotes an OCCASION — an occurrence or happening whose head noun behaves as a soft type. For occasion sorts, “the [modifier] [head]” lets the modifier do the referring (the same event can be a “trip”, a “vacation”, or a “holiday”), so two such definite descriptions corefer when their modifier matches and their head sorts agree.

Concrete physical objects (box, ball) are NOT occasions: “the red box” and “the red ball” are distinct things even though both are Physical, so they must never corefer through a shared modifier.

Trait Implementations

impl Clone for Sort

fn clone(&self) -> Sort

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sort

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

Formats the value using the given formatter.

impl Hash for Sort

fn hash<__H: Hasher>(&self, state: &mut __H)

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 Sort

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

impl Eq for Sort

impl StructuralPartialEq for Sort