Enum Term 

pub enum Term {
    Variable(String),
    Atom(String),
    Integer(i64),
    Float(f64),
    Str(String),
    Anon,
    List(Vec<Term>),
    ListCons(Vec<Term>, Box<Term>),
    Compound(String, Vec<Term>),
    TypeAnnotated {
        term: Box<Term>,
        type_name: String,
    },
    Tensor(Vec<f32>),
    NeuralGradient {
        term: Box<Term>,
        model_id: String,
        grad_id: String,
    },
}

A term in Gollum logic.

Variants

Variable(String)

A logic variable (e.g., X, _).

Atom(String)

An atom (e.g., alice, 'Bob').

Integer(i64)

An integer literal (e.g., 42).

Float(f64)

A floating-point literal (e.g., 3.14).

Str(String)

A string literal (e.g., "hello").

Anon

An anonymous variable (wildcard, _).

List(Vec<Term>)

A list literal (e.g., [a, b, c]).

ListCons(Vec<Term>, Box<Term>)

A list construction (e.g., [a, b | Tail]).

Compound(String, Vec<Term>)

A compound term (e.g., point(X, Y)).

TypeAnnotated

A term with a type annotation (e.g., X:person). The type_name should be an atom (lowercase, possibly quoted).

Fields

term: Box<Term>

The underlying term.

type_name: String

The type name.

Tensor(Vec<f32>)

A dense tensor / embedding literal (e.g., #[1.0, 0.5, -0.3]).

NeuralGradient

A neural term with gradient tracking (e.g., X :: "model" :: "grad"). Combines neural model execution with bidirectional gradient flow.

Fields

term: Box<Term>

The underlying term.

model_id: String

The neural model identifier.

grad_id: String

The gradient identifier for backpropagation.

Implementations

impl Term

pub fn contains_neural(&self) -> bool

Returns true if this term contains any neural gradient annotation.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Term

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Term

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

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 Serialize for Term

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 StructuralPartialEq for Term