Enum Term 

pub enum Term {
    Variable(String),
    Anonymous,
    Integer(i64),
    Float(f64),
    String(String),
    Symbol(u32),
    List(Vec<Term>),
    Cons {
        head: Box<Term>,
        tail: Box<Term>,
    },
    Compound {
        functor: String,
        args: Vec<Term>,
    },
    PredRef(String),
    Aggregate(AggExpr),
}

A term in an atom

Variants

Variable(String)

Named logic variable (e.g. X).

Anonymous

Anonymous wildcard _ – each occurrence is a fresh unnamed variable.

Integer(i64)

Integer literal.

Float(f64)

Floating-point literal.

String(String)

Quoted string literal.

Symbol(u32)

Interned symbol ID – use xlog_core::symbol::resolve(id) to get the string.

List(Vec<Term>)

Finite list literal.

Cons

Finite cons pattern [Head | Tail].

Fields

head: Box<Term>

Head term.

tail: Box<Term>

Tail term.

Compound

Finite compound term.

Fields

functor: String

Functor name.

args: Vec<Term>

Compound arguments.

PredRef(String)

Static predicate reference.

Aggregate(AggExpr)

Aggregate expression (e.g. count(X)).

Implementations

impl Term

pub fn is_variable(&self) -> bool

Returns true if this is a named variable.

pub fn is_anonymous(&self) -> bool

Returns true if this is an anonymous wildcard _

pub fn is_any_variable(&self) -> bool

Returns true if this is any kind of variable (named or anonymous)

pub fn is_constant(&self) -> bool

Returns true if this is a ground (non-variable, non-aggregate) term.

pub fn variable_name(&self) -> Option<&str>

Returns the variable name, or None for anonymous/constants

pub fn variables(&self) -> Vec<&str>

Return all named variables referenced by this term.

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl PartialEq for Term

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