Enum Expr 

pub enum Expr {
    Literal(Literal),
    Ident(String),
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Expr>,
    },
    Member {
        object: Box<Expr>,
        property: Box<Expr>,
        computed: bool,
    },
    Array(Vec<Expr>),
    Object(Vec<(String, Expr)>),
    Function(Box<Function>),
    Conditional {
        test: Box<Expr>,
        consequent: Box<Expr>,
        alternate: Box<Expr>,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
}

An expression that produces a value.

Variants

Literal(Literal)

Literal value.

Ident(String)

Variable reference.

Binary

Binary operation: left op right.

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

Unary

Unary operation: op expr.

Fields

op: UnaryOp

expr: Box<Expr>

Call

Function call: callee(args...).

Fields

callee: Box<Expr>

args: Vec<Expr>

Member

Member access: object.property or object[property].

Fields

object: Box<Expr>

property: Box<Expr>

computed: bool

True for obj[expr], false for obj.ident.

Array(Vec<Expr>)

Array literal: [a, b, c].

Object(Vec<(String, Expr)>)

Object literal: { key: value, ... }.

Function(Box<Function>)

Anonymous function: function(params) { body }.

Conditional

Ternary/conditional: cond ? then : else.

Fields

test: Box<Expr>

consequent: Box<Expr>

alternate: Box<Expr>

Assign

Assignment: target = value.

Fields

target: Box<Expr>

value: Box<Expr>

Implementations

impl Expr

pub fn null() -> Self

pub fn bool(v: bool) -> Self

pub fn number(v: impl Into<f64>) -> Self

pub fn string(v: impl Into<String>) -> Self

pub fn ident(name: impl Into<String>) -> Self

pub fn binary(left: Expr, op: BinaryOp, right: Expr) -> Self

pub fn unary(op: UnaryOp, expr: Expr) -> Self

pub fn call(callee: Expr, args: Vec<Expr>) -> Self

pub fn member(object: Expr, property: impl Into<String>) -> Self

pub fn index(object: Expr, index: Expr) -> Self

pub fn array(items: Vec<Expr>) -> Self

pub fn object(pairs: Vec<(String, Expr)>) -> Self

pub fn conditional(test: Expr, consequent: Expr, alternate: Expr) -> Self

pub fn assign(target: Expr, value: Expr) -> Self

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expr

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructureEq for Expr

fn structure_eq(&self, other: &Self) -> bool

Compare two values for structural equality.

impl StructuralPartialEq for Expr