Enum Expression 

pub enum Expression {
    Integer {
        value: i64,
        position: Position,
    },
    Float {
        value: f64,
        position: Position,
    },
    String {
        value: String,
        position: Position,
    },
    Boolean {
        value: bool,
        position: Position,
    },
    Null {
        position: Position,
    },
    Identifier {
        name: String,
        position: Position,
    },
    Binary {
        left: Box<Expression>,
        operator: BinaryOp,
        right: Box<Expression>,
        position: Position,
    },
    Unary {
        operator: UnaryOp,
        operand: Box<Expression>,
        position: Position,
    },
    Assignment {
        name: String,
        value: Box<Expression>,
        position: Position,
    },
    Call {
        function: String,
        arguments: Vec<Expression>,
        position: Position,
    },
    MethodCall {
        receiver: Box<Expression>,
        method: String,
        arguments: Vec<Expression>,
        position: Position,
    },
    Grouped {
        expression: Box<Expression>,
        position: Position,
    },
    ArrayLiteral {
        elements: Vec<Expression>,
        position: Position,
    },
    DictionaryLiteral {
        pairs: Vec<(Expression, Expression)>,
        position: Position,
    },
}

An expression in FiddlerScript.

Variants

Integer

Integer literal: 42

Fields

value: i64

The integer value

position: Position

Source position

Float

Float literal: 3.14

Fields

value: f64

The float value

position: Position

Source position

String

String literal: "hello"

Fields

value: String

The string value

position: Position

Source position

Boolean

Boolean literal: true or false

Fields

value: bool

The boolean value

position: Position

Source position

Null

Null literal: null

Fields

position: Position

Source position

Identifier

Variable reference: x

Fields

name: String

The variable name

position: Position

Source position

Binary

Binary operation: a + b

Fields

left: Box<Expression>

Left operand

operator: BinaryOp

The binary operator

right: Box<Expression>

Right operand

position: Position

Source position

Unary

Unary operation: -x or !x

Fields

operator: UnaryOp

The unary operator

operand: Box<Expression>

The operand expression

position: Position

Source position

Assignment

Assignment: x = value

Fields

name: String

The variable name being assigned

value: Box<Expression>

The value expression

position: Position

Source position

Call

Function call: foo(args)

Fields

function: String

The function name

arguments: Vec<Expression>

The argument expressions

position: Position

Source position

MethodCall

Method call: expr.method(args)

Fields

receiver: Box<Expression>

The receiver expression (object the method is called on)

method: String

The method name

arguments: Vec<Expression>

The argument expressions

position: Position

Source position

Grouped

Grouped expression: (expr)

Fields

expression: Box<Expression>

The inner expression

position: Position

Source position

ArrayLiteral

Array literal: [1, 2, 3]

Fields

elements: Vec<Expression>

The array element expressions

position: Position

Source position

DictionaryLiteral

Dictionary literal: {"key": value, "another": 42}

Fields

pairs: Vec<(Expression, Expression)>

Key-value pairs where keys are string expressions

position: Position

Source position

Implementations

impl Expression

pub fn position(&self) -> Position

Get the position 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