Enum Value 

pub enum Value {
    Object(ScopePtr),
    Patch(Thunk),
    Array(Vec<Thunk>),
    Number(f64),
    String(String),
    Boolean(bool),
    FunctionCall {
        f: Thunk,
        args: Vec<Thunk>,
    },
    BuiltinFn(BuiltinFn),
    Lambda {
        scope: ScopePtr,
        arg_names: Vec<String>,
        expr: Rc<AstNode>,
    },
    BinOp {
        kind: BinOp,
        left: Thunk,
        right: Thunk,
    },
    Name(ScopePtr, String),
    Attribute {
        value: Thunk,
        attr: String,
    },
    Null,
}

Variants

Object(ScopePtr)

Patch(Thunk)

Array(Vec<Thunk>)

Number(f64)

String(String)

Boolean(bool)

FunctionCall

Fields

f: Thunk

args: Vec<Thunk>

BuiltinFn(BuiltinFn)

Lambda

Fields

scope: ScopePtr

arg_names: Vec<String>

expr: Rc<AstNode>

BinOp

Fields

kind: BinOp

left: Thunk

right: Thunk

Name(ScopePtr, String)

Attribute

Fields

value: Thunk

attr: String

Null

Implementations

impl Value

pub fn is_primitive(&self) -> bool

pub fn at(&self, index: usize) -> Result<Rc<Value>, Error>

pub fn attr(&self, attr: &str) -> Result<Rc<Value>, Error>

pub fn str(&self) -> Result<&str, Error>

pub fn number(&self) -> Result<f64, Error>

pub fn bool(&self) -> Result<bool, Error>

pub fn is_null(&self) -> bool

pub fn pretty_indented( &self, indent: usize, _color: bool, f: &mut Formatter<'_>, ) -> Result

pub fn pretty(&self, color: bool, f: &mut Formatter<'_>) -> Result

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

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.