Enum Expression 

pub enum Expression {
    String(Vec<StringPart>, Span),
    Number(f64, Span),
    Boolean(bool, Span),
    Identifier(String, Span),
    Null(Span),
    Array(Vec<Expression>, Span),
    Object(Vec<(String, Expression)>, Span),
    Binary(BinaryOp, Box<Expression>, Box<Expression>, Span),
    Unary(UnaryOp, Box<Expression>, Span),
    Call(Box<Expression>, Vec<Expression>, Span),
    Member(Box<Expression>, String, Span),
    Index(Box<Expression>, Box<Expression>, Span),
    Range(Box<Expression>, Box<Expression>, Span),
    Lambda(Lambda),
    Match(MatchExpr),
}

An expression in GENT

Variants

String(Vec<StringPart>, Span)

String literal: "hello" or interpolated string: "Hello, ${name}!"

Number(f64, Span)

Number literal: 42 or 3.14

Boolean(bool, Span)

Boolean literal: true or false

Identifier(String, Span)

Identifier reference: varName

Null(Span)

Null literal: null

Array(Vec<Expression>, Span)

Array literal: [1, 2, 3]

Object(Vec<(String, Expression)>, Span)

Object literal: {key: value}

Binary(BinaryOp, Box<Expression>, Box<Expression>, Span)

Binary operation: a + b

Unary(UnaryOp, Box<Expression>, Span)

Unary operation: -x, !x

Call(Box<Expression>, Vec<Expression>, Span)

Function call: foo(args)

Member(Box<Expression>, String, Span)

Member access: obj.prop

Index(Box<Expression>, Box<Expression>, Span)

Index access: arr[0]

Range(Box<Expression>, Box<Expression>, Span)

Range expression (start..end)

Lambda(Lambda)

Lambda expression: (x) => x * 2

Match(MatchExpr)

Match expression: match value { Pattern => result }

Implementations

impl Expression

pub fn span(&self) -> &Span

Get the span of this expression

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl PartialEq for Expression

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