Enum Value

pub enum Value {
    String(String),
    Number(f64),
    List(Vec<Ref<Self>>),
    Tree(BTreeMap<String, Ref<Self>>),
    Function(Function<Machine, (), Machine>),
    Error(String),
    None,
}

Variants

String(String)

Number(f64)

List(Vec<Ref<Self>>)

Tree(BTreeMap<String, Ref<Self>>)

Function(Function<Machine, (), Machine>)

Error(String)

None

Implementations

impl Value

pub fn number<N: Into<f64>>(n: N) -> Ref<Self>

Creates a new reference to a Number

pub fn string<S: ToString>(s: S) -> Ref<Self>

Creates a new reference to a String

pub fn list() -> Ref<Self>

Creates a new reference to an empty List

pub fn tree() -> Ref<Self>

Creates a new reference to an empty Tree

pub fn function( f: impl 'static + Fn(&mut Machine), context: &Machine, ) -> Ref<Self>

Creates a reference to a Function with a captured context, basically a Closure

pub fn error<S: ToString>(s: S) -> Ref<Self>

Creates a reference to an Error value

pub fn none() -> Ref<Self>

Creates a reference to an None value

pub fn copy(&self) -> Ref<Self>

Copies the contents of this value

pub fn call(&self, machine: &mut Machine)

Call this function in the context of the Machine captured when this instance of the function was created

pub fn call_global(&self, machine: &mut Machine)

Call this function in the context of the current machine, meaning, execute the instructions of this function as if they were not in a function.

pub fn is_err(&self) -> bool

pub fn index<S: ToString>(&mut self, s: S) -> Ref<Self>

Return a reference to a value contained within a collection

Trait Implementations

impl Add for Value

############################################################## The following traits are for implementing operators and logic! ############################################################## Add two values

type Output = Value

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

This implementation is a hack for implementing Display for Value

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

Formats the value using the given formatter.

impl Display for Value

How to display value

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

Formats the value using the given formatter.

impl Div for Value

Divide two values

type Output = Value

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl From<&str> for Value

Make Value from &str

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<BTreeMap<String, Rc<Value>>> for Value

Make Value from Tree

fn from(t: BTreeMap<String, Ref<Value>>) -> Self

Converts to this type from the input type.

impl From<String> for Value

Make Value from String

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Value> for BTreeMap<String, Ref<Value>>

Convert Value to unwrapped Tree

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Value> for String

Get a function from the value

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Value> for Vec<Ref<Value>>

Convert Value to unwrapped List

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Value> for bool

############################################################ The following traits are for implementing foreign functions! ############################################################ Convert Value into a bool

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Value> for f64

Convert to floating point value

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Value> for i32

Convert to integer value

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<Vec<Rc<Value>>> for Value

Make Value from List

fn from(l: Vec<Ref<Value>>) -> Self

Converts to this type from the input type.

impl From<bool> for Value

Make Value from bool

fn from(n: bool) -> Self

Converts to this type from the input type.

impl From<f64> for Value

Make Value from Number

fn from(n: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Value

Make Value from Number

fn from(n: i32) -> Self

Converts to this type from the input type.

impl IntoIterator for Value

Convert Value into Iter

type Item = Rc<Value>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Value as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Mul for Value

Multiply two values

type Output = Value

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Not for Value

Negate value

type Output = Value

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Value

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

fn partial_cmp(&self, other: &Value) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem for Value

Remainder of two values

type Output = Value

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl Sub for Value

Subtract two values

type Output = Value

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl StructuralPartialEq for Value