Enum erlang_term::term::Term

source ·

pub enum Term {
Show 15 variants
    Byte(u8),
    Int(i32),
    Float(OrderedFloat<f64>),
    String(String),
    Atom(String),
    Bytes(Vec<u8>),
    Bool(bool),
    Nil,
    BigInt(BigInt),
    Charlist(Vec<u8>),
    Map(HashMap<Term, Term>),
    Keyword(Keylist<String, Term>),
    List(Vec<Term>),
    Tuple(Vec<Term>),
    Other(RawTerm),
}

Expand description

Higher level Elixir types

These can be created by using the Term::from methods or creating them directly.


let string = Term::from("ok");
let atom = Term::Atom("ok".to_string());

assert!(string.is_string());
assert!(atom.is_atom());
assert_ne!(string, atom);

The Term::as_* will unwrap the Term into a specific type if the Term is that type


let atom = Term::Atom("ok".to_string());
assert_eq!(Some("ok".to_string()), atom.as_atom());

let atom = Term::Atom("ok".to_string());
assert_eq!(None, atom.as_string());

Convert to RawTerm


let term = Term::from("testing");
let raw_term = RawTerm::from(term);

assert_eq!(RawTerm::Binary(vec![116, 101, 115, 116, 105, 110, 103]), raw_term);

Convert from RawTerm


let raw_term = RawTerm::Binary(vec![116, 101, 115, 116, 105, 110, 103]);
let term = Term::from(raw_term);

assert_eq!(Some("testing".to_string()), term.as_string());

Variants§

§

Implementations§

source §

impl Term

source

pub fn from_bytes(input: &[u8]) -> Result<Term, NomErr<Error<&[u8]>>>

source

pub fn to_bytes(self) -> Vec<u8> ⓘ

source

pub fn as_type(&self) -> RawTermType

source

pub fn as_general_type(&self) -> RawTermGeneralType

source

pub fn is_byte(&self) -> bool

source

pub fn is_string(&self) -> bool

source

pub fn is_atom(&self) -> bool

source

pub fn is_tuple(&self) -> bool

source

pub fn is_pair_tuple(&self) -> bool

Check if the Term is a tuple of length 2

let term = Term::from((1, 2));
assert!(term.is_pair_tuple());

source

pub fn is_list(&self) -> bool

source

pub fn is_string_tuple_pair(&self) -> bool

Check if the Term is of the form ("string", any)

let term = Term::from(("test", 1));
assert!(term.is_string_tuple_pair());
let term = Term::from((1, 2));
assert!(!term.is_string_tuple_pair());

source

pub fn as_bool(self) -> Option<bool>

source

pub fn as_nil(self) -> Option<()>

source

pub fn as_byte(self) -> Option<u8>

source

pub fn as_int(self) -> Option<i32>

source

pub fn as_float(self) -> Option<f64>

source

pub fn as_atom(self) -> Option<String>

source

pub fn as_string(self) -> Option<String>

source

pub fn as_bytes(self) -> Option<Vec<u8>>

source

pub fn as_charlist(self) -> Option<Vec<u8>>

source

pub fn as_big_int(self) -> Option<BigInt>

source

pub fn as_keyword(self) -> Option<Keylist<String, Term>>

source

pub fn as_list(self) -> Option<Vec<Term>>

source

pub fn as_tuple(self) -> Option<Vec<Term>>

source

pub fn as_map(self) -> Option<HashMap<Term, Term>>

source

pub fn as_string_map(self) -> Option<HashMap<String, Term>>

Unwrap and convert the term into a HashMap<String, Term> if the term is a map and all the keys are strings Note that this will create a new map, so for one-offs you should use the Term::as_map function

source

pub fn as_atom_map(self) -> Option<HashMap<String, Term>>

Unwrap and convert the term into a HashMap<String, Term> if the term is a map and all the keys are atoms Note that this will create a new map, so for one-offs you should use the Term::as_map function

Trait Implementations§

source §

impl Clone for Term

source §

fn clone(&self) -> Term

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

source §

impl Debug for Term

source §

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

Formats the value using the given formatter. Read more

source §

impl Display for Term

source §

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

Formats the value using the given formatter. Read more

source §