Enum Value

pub enum Value<'a> {
    Undefined,
    Null,
    Number(f64),
    Bool(bool),
    String(String<'a>),
    Regex(Box<RegexLiteral>),
    Array(Vec<'a, &'a Value<'a>>, ArrayFlags),
    Object(HashMap<String<'a>, &'a Value<'a>, DefaultHashBuilder, &'a Bump>),
    Range(Range<'a>),
    Lambda {
        ast: Box<'a, Ast>,
        input: &'a Value<'a>,
        frame: Frame<'a>,
    },
    NativeFn {
        name: String,
        arity: usize,
        func: fn(FunctionContext<'a, '_>, &[&'a Value<'a>]) -> Result<&'a Value<'a>>,
    },
    Transformer {
        pattern: Box<Ast>,
        update: Box<Ast>,
        delete: Option<Box<Ast>>,
    },
}

The core value type for input, output and evaluation.

There’s a lot of lifetimes here to avoid cloning any part of the input that should be kept in the output, avoiding heap allocations for every Value, and allowing structural sharing.

Values are all allocated in a Bump arena, making them contiguous in memory and further avoiding heap allocations for every one.

Variants

Undefined

Null

Number(f64)

Bool(bool)

String(String<'a>)

Regex(Box<RegexLiteral>)

Array(Vec<'a, &'a Value<'a>>, ArrayFlags)

Object(HashMap<String<'a>, &'a Value<'a>, DefaultHashBuilder, &'a Bump>)

Range(Range<'a>)

Lambda

Fields

ast: Box<'a, Ast>

input: &'a Value<'a>

frame: Frame<'a>

NativeFn

Fields

name: String

arity: usize

func: fn(FunctionContext<'a, '_>, &[&'a Value<'a>]) -> Result<&'a Value<'a>>

Transformer

Fields

pattern: Box<Ast>

update: Box<Ast>

delete: Option<Box<Ast>>

Implementations

impl<'a> Value<'a>

pub fn undefined() -> &'a Value<'a>

pub fn null(arena: &Bump) -> &mut Value<'_>

pub fn bool(value: bool) -> &'a Value<'a>

pub fn number(arena: &Bump, value: impl Into<f64>) -> &mut Value<'_>

pub fn number_from_u128(arena: &Bump, value: u128) -> Result<&mut Value<'_>>

pub fn string(arena: &'a Bump, value: &str) -> &'a mut Value<'a>

pub fn array(arena: &Bump, flags: ArrayFlags) -> &mut Value<'_>

pub fn array_from( arena: &'a Bump, arr: BumpVec<'a, &'a Value<'a>>, flags: ArrayFlags, ) -> &'a mut Value<'a>

pub fn array_with_capacity( arena: &Bump, capacity: usize, flags: ArrayFlags, ) -> &mut Value<'_>

pub fn object(arena: &Bump) -> &mut Value<'_>

pub fn object_from<H>( hash: &HashMap<BumpString<'a>, &'a Value<'a>, H, &'a Bump>, arena: &'a Bump, ) -> &'a mut Value<'a>

pub fn object_with_capacity(arena: &Bump, capacity: usize) -> &mut Value<'_>

pub fn lambda( arena: &'a Bump, node: &Ast, input: &'a Value<'a>, frame: Frame<'a>, ) -> &'a mut Value<'a>

pub fn nativefn( arena: &'a Bump, name: &str, arity: usize, func: fn(FunctionContext<'a, '_>, &[&'a Value<'a>]) -> Result<&'a Value<'a>>, ) -> &'a mut Value<'a>

pub fn transformer( arena: &'a Bump, pattern: &Box<Ast>, update: &Box<Ast>, delete: &Option<Box<Ast>>, ) -> &'a mut Value<'a>

pub fn range(arena: &'a Bump, start: isize, end: isize) -> &'a mut Value<'a>

pub fn range_from(arena: &'a Bump, range: &'a Range<'_>) -> &'a mut Value<'a>

pub fn is_undefined(&self) -> bool

pub fn is_null(&self) -> bool

pub fn is_bool(&self) -> bool

pub fn is_number(&self) -> bool

pub fn is_integer(&self) -> bool

pub fn is_array_of_valid_numbers(&self) -> Result<bool>

pub fn is_array_of_strings(&self) -> bool

pub fn is_valid_number(&self) -> Result<bool>

pub fn is_nan(&self) -> bool

pub fn is_finite(&self) -> bool

pub fn is_string(&self) -> bool

pub fn is_array(&self) -> bool

pub fn is_object(&self) -> bool

pub fn is_function(&self) -> bool

pub fn is_truthy(&'a self) -> bool

pub fn get_member(&self, index: usize) -> &'a Value<'a>

pub fn members(&'a self) -> MemberIterator<'a>

pub fn entries(&self) -> Iter<'_, BumpString<'a>, &'a Value<'_>>

pub fn arity(&self) -> usize

pub fn as_bool(&self) -> bool

pub fn as_f64(&self) -> f64

pub fn as_usize(&self) -> usize

pub fn as_isize(&self) -> isize

pub fn as_str(&self) -> Cow<'_, str>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get_entry(&self, key: &str) -> &'a Value<'a>

pub fn remove_entry(&mut self, key: &str)

pub fn push(&mut self, value: &'a Value<'a>)

pub fn insert(&mut self, key: &str, value: &'a Value<'a>)

pub fn remove(&mut self, key: &str)

pub fn flatten(&'a self, arena: &'a Bump) -> &'a mut Value<'a>

pub fn wrap_in_array( arena: &'a Bump, value: &'a Value<'a>, flags: ArrayFlags, ) -> &'a mut Value<'a>

pub fn wrap_in_array_if_needed( arena: &'a Bump, value: &'a Value<'a>, flags: ArrayFlags, ) -> &'a Value<'a>

pub fn get_flags(&self) -> ArrayFlags

pub fn has_flags(&self, check_flags: ArrayFlags) -> bool

pub fn clone(&'a self, arena: &'a Bump) -> &'a mut Value<'a>

pub fn clone_array_with_flags( &self, arena: &'a Bump, flags: ArrayFlags, ) -> &'a mut Value<'a>

pub fn serialize(&'a self, pretty: bool) -> String

pub fn __very_unsafe_make_mut(&'a self) -> &'a mut Value<'a>

Trait Implementations

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 Hash for Value<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Index<&str> for Value<'a>

type Output = Value<'a>

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<usize> for Value<'a>

type Output = Value<'a>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl PartialEq<&str> for Value<'_>

fn eq(&self, other: &&str) -> 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 PartialEq<bool> for Value<'_>

fn eq(&self, other: &bool) -> 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 PartialEq<isize> for Value<'_>

fn eq(&self, other: &isize) -> 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 PartialEq<usize> for Value<'_>

fn eq(&self, other: &usize) -> 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<'a> PartialEq for Value<'a>

fn eq(&self, other: &Value<'a>) -> 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 Eq for Value<'_>