Enum wlambda::vval::VVal

pub enum VVal {
    Nul,
    Err(Rc<RefCell<(VVal, SynPos)>>),
    Bol(bool),
    Sym(String),
    Str(Rc<RefCell<String>>),
    Byt(Rc<RefCell<Vec<u8>>>),
    Int(i64),
    Flt(f64),
    Syn(SynPos),
    Lst(Rc<RefCell<Vec<VVal>>>),
    Map(Rc<RefCell<HashMap<String, VVal>>>),
    Fun(Rc<VValFun>),
    DropFun(Rc<DropVVal>),
    Ref(Rc<RefCell<VVal>>),
    CRef(Rc<RefCell<VVal>>),
    WWRef(Weak<RefCell<VVal>>),
    Usr(Box<dyn VValUserData>),
}

VVal aka. VariantValue is a data structure to represent all kinds of WLambda data structures.

It's used for the AST, for internal data and for runtime data structures.

Variants

Nul

The none value, the default value of all non initialized data.

Err(Rc<RefCell<(VVal, SynPos)>>)

The err value is a special sentinel value for representing any kind of application error condition. It's created using the special $e or $error syntax.

Bol(bool)

Representation of a boolean value.

Sym(String)

Representation of a symbol or key.

This one might be interned at some point, so that it only contains an Rc in future.

Str(Rc<RefCell<String>>)

Representation of a unicode/text string.

Byt(Rc<RefCell<Vec<u8>>>)

Representation of a byte buffer.

Int(i64)

Integer value

Flt(f64)

Float value

Syn(SynPos)

A syntax node in the AST, records the position too.

Lst(Rc<RefCell<Vec<VVal>>>)

A list (or vector) of VVals.

Map(Rc<RefCell<HashMap<String, VVal>>>)

A mapping of strings to VVals.

Fun(Rc<VValFun>)

A function, see also VValFun

DropFun(Rc<DropVVal>)

A guarded VVal, that executes a given function when it is no longer referenced.

Ref(Rc<RefCell<VVal>>)

A (strong) reference to a VVal.

CRef(Rc<RefCell<VVal>>)

A (still strong) reference to a VVal, which becomes a weak reference if captured by a closure.

WWRef(Weak<RefCell<VVal>>)

A (weak) reference to a VVal. Might turn VVal::Nul anytime.

Usr(Box<dyn VValUserData>)

A vval that can box some user data which can later be accessed from inside user supplied Rust functions via std::any::Any.

Methods

impl VVal

pub fn new_str(s: &str) -> VVal

pub fn new_str_mv(s: String) -> VVal

pub fn new_sym(s: &str) -> VVal

pub fn new_byt(v: Vec<u8>) -> VVal

pub fn err(v: VVal, pos: SynPos) -> VVal

pub fn err_msg(s: &str) -> VVal

pub fn vec() -> VVal

pub fn to_vec(&self) -> Vec<VVal>

pub fn vec_from(vl: &[VVal]) -> VVal

pub fn vec_mv(v: Vec<VVal>) -> VVal

pub fn call(&self, env: &mut Env, args: &[VVal]) -> Result<VVal, StackAction>

pub fn call_no_args(&self, env: &mut Env) -> Result<VVal, StackAction>

pub fn call_internal(
    &self,
    env: &mut Env,
    argc: usize
) -> Result<VVal, StackAction>

pub fn to_ref(&self) -> VVal

pub fn to_wref(&self) -> VVal

pub fn set_ref(&self, v: VVal) -> VVal

pub fn deref(&self) -> VVal

pub fn downgrade(self) -> VVal

pub fn map() -> VVal

pub fn sym(s: &str) -> VVal

pub fn ref_id(&self) -> Option<i64>

pub fn eqv(&self, v: &VVal) -> bool

pub fn map_ok_skip<T, R>(&self, op: T, skip: usize) -> Vec<R> where
    T: FnMut(&VVal) -> R, 

pub fn map_skip<R, E, T>(&self, op: T, skip: usize) -> Result<Vec<R>, E> where
    T: FnMut(&VVal) -> Result<R, E>, 

pub fn unshift(&self, val: VVal) -> &VVal

pub fn insert_at(&self, index: usize, val: VVal)

pub fn set_at(&self, index: usize, val: VVal)

pub fn at(&self, index: usize) -> Option<VVal>

pub fn get_key(&self, key: &str) -> Option<VVal>

pub fn set_map_key(&self, key: String, val: VVal)

pub fn set_key(&self, key: &VVal, val: VVal)

pub fn pop(&self) -> VVal

pub fn push(&self, val: VVal) -> &VVal

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn s_len(&self) -> usize

pub fn s_raw(&self) -> String

pub fn is_float(&self) -> bool

pub fn is_int(&self) -> bool

pub fn is_sym(&self) -> bool

pub fn is_syn(&self) -> bool

pub fn get_syn_pos(&self) -> SynPos

pub fn get_syn(&self) -> Syntax

pub fn to_compile_err(&self, msg: String) -> Result<EvalNode, CompileError>

pub fn is_ref(&self) -> bool

pub fn is_wref(&self) -> bool

pub fn is_bool(&self) -> bool

pub fn is_bytes(&self) -> bool

pub fn is_str(&self) -> bool

pub fn is_fun(&self) -> bool

pub fn is_vec(&self) -> bool

pub fn is_map(&self) -> bool

pub fn is_none(&self) -> bool

pub fn is_err(&self) -> bool

pub fn type_name(&self) -> String

pub fn f(&self) -> f64

pub fn i(&self) -> i64

pub fn b(&self) -> bool

pub fn s(&self) -> String

pub fn to_msgpack(&self) -> Result<Vec<u8>, String>

Serializes the VVal (non cyclic) structure to a msgpack byte vector.

pub fn from_msgpack(s: &[u8]) -> Result<VVal, String>

Creates a VVal structure from a msgpack byte vector.

pub fn to_json(&self, not_pretty: bool) -> Result<String, String>

Serializes the VVal (non cyclic) structure to a JSON string.

pub fn from_json(s: &str) -> Result<VVal, String>

Creates a VVal structure from a JSON string.

Trait Implementations

impl Clone for VVal

fn clone(&self) -> VVal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VVal

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

Formats the value using the given formatter.

impl Serialize for VVal

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for VVal

fn deserialize<D>(deserializer: D) -> Result<VVal, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.