Enum aterm::Term

pub enum Term<Rec, Blob, S> {
    Int(i32),
    Long(i64),
    Real(BrokenF32),
    Application(S, Box<[Rec]>),
    List(Box<[Rec]>),
    Placeholder(TermPlaceholder<Rec>),
    Blob(Blob),
}

The basic term type, without annotations

Variants

Int(i32)

An 32bit signed integer

Long(i64)

A 64bit signed integer. This is an optional component in the spec, but it's easy to support.

Real(BrokenF32)

An 32bit floating point number, but with a broken equality so a coherent implementation of Hash could be given (if NaN != NaN, then what Hash should it get?). You shouldn't directly check equality of floating point numbers anyways because of rounding.

Application(S, Box<[Rec]>)

The main thing: Application of a constructor, using a string for the constructor name.

List(Box<[Rec]>)

A list of ATerms.

Placeholder(TermPlaceholder<Rec>)

A placeholder for pattern matching. Only here for compatibility with the spec, use Rust's pattern matching facilities instead!

Blob(Blob)

A Binary Large OBject. Here used to embed any other type. Note it will need to implement some traits if you still want to parse or print it.

Trait Implementations

impl<Rec: Debug, Blob: Debug, S: Debug> Debug for Term<Rec, Blob, S>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Rec: PartialEq, Blob: PartialEq, S: PartialEq> PartialEq for Term<Rec, Blob, S>

fn eq(&self, __arg_0: &Term<Rec, Blob, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Term<Rec, Blob, S>) -> bool

This method tests for !=.

impl<Rec: Eq, Blob: Eq, S: Eq> Eq for Term<Rec, Blob, S>

impl<Rec: Clone, Blob: Clone, S: Clone> Clone for Term<Rec, Blob, S>

fn clone(&self) -> Term<Rec, Blob, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Rec: Hash, Blob: Hash, S: Hash> Hash for Term<Rec, Blob, S>

fn hash<__HRecBlobS: Hasher>(&self, __arg_0: &mut __HRecBlobS)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<Rec, B, S> Display for Term<Rec, B, S> where
    Rec: ATermWrite,
    B: ATermWrite,
    S: Display, 

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

Formats the value using the given formatter.

impl<Rec, B, S> ATermWrite for Term<Rec, B, S> where
    Rec: ATermWrite,
    B: ATermWrite,
    S: Display, 

fn to_ascii<W: Write>(&self, writer: &mut W) -> Result

fn to_taf<W: Write>(&self, writer: &mut W) -> Result

fn to_baf<W: Write>(&self, writer: &mut W) -> Result

fn to_saf<W: Write>(&self, writer: &mut W) -> Result

fn to_ascii_string(&self) -> Result<String, Error>

fn to_taf_string(&self) -> Result<String, Error>

fn to_baf_string(&self) -> Result<String, Error>

fn to_saf_string(&self) -> Result<String, Error>