Enum TermValue

pub enum TermValue {
    SmallInt(i32),
    Atom(AtomIndex),
    Nil,
    Pid(ProcessId),
    Port(PortId),
    Reference(RefId),
    Tuple(Vec<TermValue>),
    List(Box<TermValue>, Box<TermValue>),
    Map(Vec<(TermValue, TermValue)>),
    Binary(Vec<u8>),
    Function(FunctionRef),
    Resource(ResourceRef),
    Float(f64),
    Invalid,
}

Clean, functional ADT for AtomVM terms

This is completely generic - it works with any atom table implementation through the AtomTableOps trait.

Variants

SmallInt(i32)

Atom(AtomIndex)

Nil

Pid(ProcessId)

Port(PortId)

Reference(RefId)

Tuple(Vec<TermValue>)

List(Box<TermValue>, Box<TermValue>)

Map(Vec<(TermValue, TermValue)>)

Binary(Vec<u8>)

Function(FunctionRef)

Resource(ResourceRef)

Float(f64)

Invalid

Implementations

impl TermValue

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

Pattern match on integers

pub fn as_atom(&self) -> Option<AtomIndex>

Pattern match on atoms

pub fn as_tuple(&self) -> Option<&[TermValue]>

Pattern match on tuples

pub fn as_list(&self) -> Option<(&TermValue, &TermValue)>

Pattern match on lists (functional style)

pub fn is_nil(&self) -> bool

Check if this is nil

pub fn is_empty_list(&self) -> bool

Check if this is an empty list

pub fn fold_list<T, F>(&self, init: T, f: F) -> T

where F: Fn(T, &TermValue) -> T,

Fold over list elements (functional programming!)

pub fn map_list<F>(&self, f: F) -> TermValue

where F: Fn(&TermValue) -> TermValue + Clone,

Map over list elements

pub fn filter_list<F>(&self, predicate: F) -> TermValue

where F: Fn(&TermValue) -> bool + Clone,

Filter list elements

pub fn list_length(&self) -> usize

Get list length

pub fn list_to_vec(&self) -> Vec<TermValue>

Convert list to Vec

pub fn map_get(&self, key: &TermValue) -> Option<&TermValue>

Get map value by key (functional lookup)

pub fn map_set(&self, key: TermValue, value: TermValue) -> TermValue

Set map value (returns new map)

pub fn from_iter<I>(iter: I) -> TermValue

where I: IntoIterator<Item = TermValue>, I::IntoIter: DoubleEndedIterator,

Construct list from iterator (functional construction)

pub fn from_vec(elements: Vec<TermValue>) -> TermValue

Construct proper list from Vec

impl TermValue

pub fn int(value: i32) -> Self

pub fn atom<T: AtomTableOps>(name: &str, table: &T) -> Self

Create atom using any atom table (GENERIC!)

pub fn tuple(elements: Vec<TermValue>) -> Self

pub fn list(elements: Vec<TermValue>) -> Self

pub fn binary(data: Vec<u8>) -> Self

pub fn map(pairs: Vec<(TermValue, TermValue)>) -> Self

pub fn pid(id: u32) -> Self

pub fn port(id: u32) -> Self

pub fn reference(id: u64) -> Self

pub fn float(value: f64) -> Self

impl TermValue

pub fn to_int_or(&self, default: i32) -> i32

Extract integer with default

pub fn tuple_get(&self, index: usize) -> Option<&TermValue>

Extract tuple element by index

pub fn tuple_arity(&self) -> usize

Extract tuple arity

pub fn sum_list(&self) -> i32

Example: Sum all integers in a list

pub fn double_ints(&self) -> TermValue

Example: Convert list of integers to list of their doubles

pub fn is_atom_str<T: AtomTableOps>(&self, name: &str, table: &T) -> bool

Check if atom matches string using any atom table (GENERIC!)

pub fn as_atom_str<T: AtomTableOps>(&self, table: &T) -> Option<String>

Get atom as string using any atom table (GENERIC!)

Trait Implementations

impl Clone for TermValue

fn clone(&self) -> TermValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TermValue

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

Formats the value using the given formatter.

impl PartialEq for TermValue

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