Enum wlambda::vval::VVal

pub enum VVal {
    None,
    Err(Rc<RefCell<(VVal, SynPos)>>),
    Bol(bool),
    Sym(Symbol),
    Str(Rc<String>),
    Byt(Rc<Vec<u8>>),
    Int(i64),
    Flt(f64),
    Syn(SynPos),
    Pair(Rc<(VVal, VVal)>),
    Opt(Option<Rc<VVal>>),
    Iter(Rc<RefCell<VValIter>>),
    Lst(Rc<RefCell<Vec<VVal>>>),
    Map(Rc<RefCell<FnvHashMap<Symbol, VVal>>>),
    Fun(Rc<VValFun>),
    DropFun(Rc<DropFun>),
    FVec(Box<NVec<f64>>),
    IVec(Box<NVec<i64>>),
    Ref(Rc<RefCell<VVal>>),
    HRef(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

None

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(Symbol)

Representation of an interned string aka symbol or key.

Str(Rc<String>)

Representation of a unicode/text string.

Byt(Rc<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.

Pair(Rc<(VVal, VVal)>)

A pair

Opt(Option<Rc<VVal>>)

An optional value. While VVal::None basically has the same meaning as "no value", an optional value provides functions a way to say that they don't even return none value but nothing. Yes, it sounds weird, and it is weird. But in case of iterator functions that iterate over an array you can find out whether the iterator is at the end or will provide more values.

Iter(Rc<RefCell<VValIter>>)

A special internal iterator type for built in VVal data structures.

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

A list (or vector) of VVals.

Map(Rc<RefCell<FnvHashMap<Symbol, VVal>>>)

A mapping of strings to VVals.

Fun(Rc<VValFun>)

A function, see also VValFun

DropFun(Rc<DropFun>)

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

FVec(Box<NVec<f64>>)

A numerical (mathematical) vector storing integers. See NVec for more information.

IVec(Box<NVec<i64>>)

A numerical (mathematical) vector storing floats. See NVec for more information.

Ref(Rc<RefCell<VVal>>)

A (strong) reference to a VVal.

HRef(Rc<RefCell<VVal>>)

A hidden strong reference to a VVal. Generated either explicitly by $& or if a variable is captured by a closure.

WWRef(Weak<RefCell<VVal>>)

A (weak) reference to a VVal. Might turn VVal::None 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.

Implementations

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_sym_mv(s: String) -> 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 vec1(a: VVal) -> VVal

pub fn vec2(a: VVal, b: VVal) -> VVal

pub fn vec3(a: VVal, b: VVal, c: VVal) -> VVal

pub fn opt(v: VVal) -> VVal

pub fn opt_none() -> VVal

pub fn pair(a: VVal, b: VVal) -> 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 compare_str(&self, b: &VVal) -> Ordering

pub fn shallow_clone(&self) -> VVal

pub fn compare_num(&self, b: &VVal) -> Ordering

pub fn sort<F>(&self, compare: F) where
    F: FnMut(&VVal, &VVal) -> Ordering, 

pub fn fisher_yates_shuffle<I>(&mut self, rand: I) where
    I: FnMut() -> i64, 

pub fn keys(&self) -> VVal

pub fn values(&self) -> VVal

pub fn enumerate(&self) -> VVal

pub fn iter_over_vvals(&self) -> bool

Returns true if this vval is containing (multiple) other VVals. Usually true for: Maps, Vectors, Pairs and Opt.

Helpful if you want to iterate through a data structure by recursively iterating over a vval. Without getting iterations over individual string characters.

pub fn iter(&self) -> VValIter

This function returns you an iterator over the VVal. It will iterate over data such as VVal::Str, VVal::Sym, VVal::Lst, VVal::Map and VVal::Byt.

This functionality provides the for keyword/function in WLambda.

use wlambda::*;

let some_vec = VVal::vec();
some_vec.push(VVal::Int(10));
some_vec.push(VVal::Int(22));
some_vec.push(VVal::Int(36));

let mut sum = 0;
for (v, _) in some_vec.iter() {
    sum += v.i();
}

assert_eq!(sum, 68);

pub fn disable_function_arity(&self) -> VVal

This method will disable all arity checks of the function in the VVal. Does nothing if the VVal is not a function.

It is used for disabling checks of drop functions, as they are evaluated in their own environment and there is no proper way to report errors upwards.

pub fn clone_and_rebind_upvalues<T>(&self, f: T) -> VVal where
    T: FnOnce(&Vec<VarPos>, &mut Vec<VVal>), 

This function is an internal function that clones a function reference and assigns new upvalues to it for making a new closure instance.

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_hidden_boxed_ref(&self) -> VVal

pub fn assign_ref(&mut self, value: VVal)

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

pub fn hide_ref(self) -> VVal

pub fn upgrade(self) -> VVal

pub fn downgrade(self) -> VVal

pub fn map() -> VVal

pub fn map1(k: &str, v: VVal) -> VVal

pub fn map2(k: &str, v: VVal, k2: &str, v2: VVal) -> VVal

pub fn map3(k: &str, v: VVal, k2: &str, v2: VVal, k3: &str, v3: VVal) -> VVal

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

pub fn to_sym(&self) -> Symbol

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(&self, index: usize, val: VVal)

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

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

pub fn proto_data(&self) -> VVal

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

pub fn get_key_sym(&self, key: &Symbol) -> Option<VVal>

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

pub fn set_map_key_fun<T>(
    &self,
    key: &str,
    fun: T,
    min_args: Option<usize>,
    max_args: Option<usize>,
    err_arg_ok: bool
) where
    T: 'static + Fn(&mut Env, usize) -> Result<VVal, StackAction>, 

pub fn deref(&self) -> VVal

pub fn with_deref<O, D, R>(&self, op: O, default: D) -> R where
    O: FnOnce(&VVal) -> R,
    D: FnOnce(Option<&VVal>) -> R, 

pub fn list_operation<O, R>(&self, op: O) -> Result<R, StackAction> where
    O: FnMut(&mut RefMut<Vec<VVal>>) -> R, 

pub fn delete_key(&self, key: &VVal) -> Result<VVal, StackAction>

pub fn set_key_str(&self, key: &str, val: VVal) -> Result<(), StackAction>

pub fn set_key_sym(&self, key: Symbol, val: VVal) -> Result<(), StackAction>

pub fn set_key(&self, key: &VVal, val: VVal) -> Result<(), StackAction>

pub fn pop(&self) -> VVal

pub fn accum(&mut self, val: &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

Returns the string data or converts the value to a string for displaying. The conversion format is not for reading the value in again via the WLambda parser, it's for accessing the data as pure as possible.

Use this if you need the raw unescaped contents of VVal::Str, VVal::Sym, VVal::Byt and other VVals.

As this is used usually for generating output a VVal::None is turned into an empty string

There is also with_s_ref() which allows you to work with a reference to the string, in case you don't need to own the copy!

use wlambda::VVal;

assert_eq!(VVal::None.s_raw(), "");
assert_eq!(VVal::new_str("Test").s_raw(), "Test");

pub fn with_s_ref<T, R>(&self, f: T) -> R where
    T: FnOnce(&str) -> R, 

Like s_raw() but returns a reference to the string.

Use this if you need the raw unescaped contents of VVal::Str, VVal::Sym, VVal::Byt and other VVals.

As this is used usually for generating output a VVal::None is turned into an empty string

use wlambda::VVal;

VVal::None.with_s_ref(
    |s: &str| assert_eq!(s, ""));

VVal::new_str("Test").with_s_ref(
    |s: &str| assert_eq!(s, "Test"));

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 set_syn(&mut self, syn: Syntax)

pub fn set_syn_at(&self, idx: usize, syn: Syntax)

pub fn get_syn(&self) -> Syntax

pub fn compile_err(&self, msg: String) -> CompileError

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

pub fn is_pair(&self) -> bool

pub fn is_iter(&self) -> bool

pub fn is_optional(&self) -> bool

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_nvec(&self) -> bool

pub fn is_ivec(&self) -> bool

pub fn is_fvec(&self) -> bool

pub fn nvec_len(&self) -> usize

pub fn is_map(&self) -> bool

pub fn is_some(&self) -> bool

pub fn is_none(&self) -> bool

pub fn is_err(&self) -> bool

pub fn type_name(&self) -> &str

pub fn v_(&self, idx: usize) -> VVal

Quick access method for retrieving the VVal at index idx. Returns VVal::None if the VVal is not a VVal::Lst or no such index exists. See also the shorthands v_i, v_f, v_s and v_s_raw.

 use wlambda::VVal;
 let v = VVal::vec();
 v.push(VVal::Int(10));
 v.push(VVal::Int(11));

 assert_eq!(v.v_(1).i(), 11);
 assert_eq!(v.v_i(1),    11);

pub fn v_k(&self, key: &str) -> VVal

Quick access method for retrieving the VVal at key idx. Returns VVal::None if the VVal is not a VVal::Map or no such index exists. See also the shorthands v_ik, v_fk, v_sk and v_s_rawk.

 use wlambda::VVal;
 let v = VVal::map();
 v.set_key_str("aaa", VVal::Int(12));
 v.set_key_str("abc", VVal::Int(13));
 v.set_key_str("zyy", VVal::Int(14));

 assert_eq!(v.v_k("abc").i(), 13);
 assert_eq!(v.v_ik("aaa"),    12);
 assert_eq!(v.v_ik("zyy"),    14);

pub fn v_i(&self, idx: usize) -> i64

Quick access of an integer at the given idx. See also v_.

 let v = wlambda::VVal::vec();
 v.push(wlambda::VVal::Int(11));
 assert_eq!(v.v_i(0),    11);

pub fn v_ik(&self, key: &str) -> i64

Quick access of the integer at the given key. See also v_k.

 let v = wlambda::VVal::map();
 v.set_key_str("aaa", wlambda::VVal::new_str("10"));
 assert_eq!(v.v_ik("aaa"), 10);

pub fn v_s_raw(&self, idx: usize) -> String

Quick access of a raw string at the given idx. See also v_.

 let v = wlambda::VVal::vec();
 v.push(wlambda::VVal::Int(12));
 assert_eq!(v.v_s_raw(0), "12");

pub fn v_with_s_ref<T, R>(&self, idx: usize, f: T) -> R where
    T: FnOnce(&str) -> R, 

Quick access of a raw string as reference at the given idx. See also v_.

 let v = wlambda::VVal::vec();
 v.push(wlambda::VVal::new_str("12"));
 assert_eq!(v.v_with_s_ref(0, |s: &str| s.chars().nth(0).unwrap()), '1');

pub fn v_s_rawk(&self, key: &str) -> String

Quick access of the string at the given key. See also v_k.

 let v = wlambda::VVal::map();
 v.set_key_str("aaa", wlambda::VVal::new_str("XYX"));
 assert_eq!(v.v_s_rawk("aaa"), "XYX");

pub fn v_with_s_refk<T, R>(&self, key: &str, f: T) -> R where
    T: FnOnce(&str) -> R, 

Quick access of the string as reference at the given key. See also v_k.

 let v = wlambda::VVal::map();
 v.set_key_str("aaa", wlambda::VVal::new_str("XYX"));
 assert!(v.v_with_s_refk("aaa", |s: &str| s == "XYX"));

pub fn v_s(&self, idx: usize) -> String

Quick access of the string representation at the given idx. See also v_.

 let v = wlambda::VVal::vec();
 v.push(wlambda::VVal::Int(13));
 assert_eq!(v.v_s(0), "13");

pub fn v_sk(&self, key: &str) -> String

Quick access of the string represenation at the given key. See also v_k.

 let v = wlambda::VVal::map();
 v.set_key_str("aaa", wlambda::VVal::Flt(12.2));
 assert_eq!(v.v_sk("aaa"), "12.2");

pub fn v_f(&self, idx: usize) -> f64

Quick access of the float at the given idx. See also v_.

 let v = wlambda::VVal::vec();
 v.push(wlambda::VVal::Flt(13.2));
 assert_eq!(v.v_f(0), 13.2);

pub fn v_fk(&self, key: &str) -> f64

Quick access of the float at the given key. See also v_k.

 let v = wlambda::VVal::map();
 v.set_key_str("aaa", wlambda::VVal::Flt(12.2));
 assert_eq!(v.v_fk("aaa"), 12.2);

pub fn for_each<T>(&self, op: T) where
    T: FnMut(&VVal), 

pub fn for_eachk<T>(&self, op: T) where
    T: FnMut(&str, &VVal), 

pub fn f(&self) -> f64

pub fn i(&self) -> i64

pub fn b(&self) -> bool

pub fn nvec<N: NVecNum>(&self) -> NVec<N>

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

pub fn to_duration(&self) -> Result<Duration, VVal>

pub fn s(&self) -> String

Returns a string representation of the VVal data structure. It handles cyclic data structures fine. The purpose is to return an unambigous represenation of the data structure. That means strings are quoted and VVal::None becomes $n for instance.

If you need strings in pure form, use the s_raw() method.

use wlambda::VVal;

let v = VVal::None;
assert_eq!(v.s(), "$n");

assert_eq!(VVal::new_str("Foo").s(), "\"Foo\"");

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 AsRef<VVal> for VVal

fn as_ref(&self) -> &Self

Performs the conversion.

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<'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.

impl From<VVal> for StackAction

fn from(v: VVal) -> StackAction

Performs the conversion.

impl PartialEq<VVal> for VVal

fn eq(&self, rhs: &Self) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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.