Enum AVal 

pub enum AVal {
    None,
    Err(Box<AVal>, String),
    Bol(bool),
    Sym(String),
    Str(String),
    Byt(Vec<u8>),
    Int(i64),
    Flt(f64),
    Lst(Vec<AVal>),
    Opt(Option<Box<AVal>>),
    FVec(NVec<f64>),
    IVec(NVec<i64>),
    Pair(Box<(AVal, AVal)>),
    Map(FnvHashMap<String, AVal>),
    Chan(AValChannel),
    Slot(AtomicAValSlot),
    Atom(AtomicAVal),
    Usr(Box<dyn ThreadSafeUsr>),
}

AVal is a copy-by-value structure for storing the most important data of VVals inside an atomic container (AtomicAVal).

You can create an AVal from a VVal like this:

use wlambda::*;

let av = {
    let v = VVal::vec();
    v.push(VVal::Int(1));
    v.push(VVal::Int(2));
    v.push(VVal::Int(3));

    AVal::from_vval(&v)
};

/// You get back the VVal like this:

assert_eq!(av.to_vval().s(), "$[1,2,3]");

And get back the VVal like this:

Variants

None

Err(Box<AVal>, String)

Bol(bool)

Sym(String)

Str(String)

Byt(Vec<u8>)

Int(i64)

Flt(f64)

Lst(Vec<AVal>)

Opt(Option<Box<AVal>>)

FVec(NVec<f64>)

IVec(NVec<i64>)

Pair(Box<(AVal, AVal)>)

Map(FnvHashMap<String, AVal>)

Chan(AValChannel)

Slot(AtomicAValSlot)

Atom(AtomicAVal)

Usr(Box<dyn ThreadSafeUsr>)

Implementations

impl AVal

pub fn set_at_path(&mut self, path_idx: usize, pth: &VVal, av: AVal)

Takes a path of indices and the start index of that path, and sets the addressed slot to the given AVal. This is used by std:sync:atom:write_at.

pub fn to_vval(&self) -> VVal

Converts the AVal back to a VVal.

use wlambda::*;
assert_eq!(AVal::Sym(String::from("x")).to_vval().s(), ":x");

pub fn from_vval(v: &VVal) -> Self

Converts a VVal to an AVal.

use wlambda::*;

let av = AVal::from_vval(&VVal::new_sym("x"));
if let AVal::Sym(s) = av {
    assert_eq!(s, "x");
} else {
    assert!(false);
}

Trait Implementations

impl Debug for AVal

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

Formats the value using the given formatter.