Enum Term 

pub enum Term<'a> {
    Constant(Symbol),
    Variable(Symbol),
    Function(Symbol, &'a [Term<'a>]),
    Group(&'a [Term<'a>]),
    Possessed {
        possessor: &'a Term<'a>,
        possessed: Symbol,
    },
    Sigma(Symbol),
    Intension(Symbol),
    Kind(Symbol),
    Proposition(&'a LogicExpr<'a>),
    Value {
        kind: NumberKind,
        unit: Option<Symbol>,
        dimension: Option<Dimension>,
    },
}

First-order logic term representing entities or values.

Terms denote individuals, groups, or computed values in the domain of discourse. They serve as arguments to predicates.

Variants

Constant(Symbol)

Named individual constant (e.g., john, paris).

Variable(Symbol)

Bound or free variable (e.g., x, y).

Function(Symbol, &'a [Term<'a>])

Function application: f(t1, t2, ...) (e.g., mother(john)).

Group(&'a [Term<'a>])

Plural group for collective readings (e.g., john ⊕ mary).

Possessed

Possessive construction: john's book → Poss(john, book).

Fields

possessor: &'a Term<'a>

possessed: Symbol

Sigma(Symbol)

Definite description σ-term: σx.P(x) (“the unique x such that P”).

Intension(Symbol)

Intensional term (Montague up-arrow ^P) for de dicto readings.

Kind(Symbol)

Kind term (^Kind) — a Carlson-style kind-denoting entity, distinct from a Montague intension. Used for kind reference (“the dodo is extinct”) and as the base of a kind-level relational adjective (“dental procedure” → Pertains(x, ^Tooth); McNally & Boleda 2004, predicates of kinds).

Proposition(&'a LogicExpr<'a>)

Sentential complement (embedded clause as propositional argument).

Value

Numeric value with optional unit and dimension.

Fields

kind: NumberKind

unit: Option<Symbol>

dimension: Option<Dimension>

Implementations

impl<'a> Term<'a>

pub fn write_to<W>( &self, w: &mut W, registry: &mut SymbolRegistry, interner: &Interner, ) -> Result<(), Error>

where W: Write,

Writes the term to a writer using abbreviated symbols.

pub fn write_to_full<W>( &self, w: &mut W, registry: &mut SymbolRegistry, interner: &Interner, ) -> Result<(), Error>

where W: Write,

Writes the term to a writer using full (unabbreviated) symbols.

pub fn write_to_raw<W>( &self, w: &mut W, interner: &Interner, ) -> Result<(), Error>

where W: Write,

Writes the term preserving original case (for code generation).

pub fn transpile( &self, registry: &mut SymbolRegistry, interner: &Interner, ) -> String

Transpiles the term to a logic formula string.

Trait Implementations

impl<'a> Clone for Term<'a>

fn clone(&self) -> Term<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Term<'a>

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

Formats the value using the given formatter.

impl<'a> DisplayWith for Term<'a>

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

fn with<'a>(&'a self, interner: &'a Interner) -> WithInterner<'a, Self>

impl<'a, 'b> Resolve<'a> for Term<'b>

type Output = TermView<'a>

fn resolve(&self, interner: &'a Interner) -> TermView<'a>

impl<'a> Copy for Term<'a>