Enum Expression 

pub enum Expression {
    Invalid,
    Literal(Literal),
    FormatString(FormatString),
    ArrayExpression(ArrayExpression),
    TupleExpression(TupleExpression),
    Body(Body),
    Call(Call),
    QualifiedName(QualifiedName),
    Marker(Marker),
    BinaryOp {
        lhs: Box<Expression>,
        op: String,
        rhs: Box<Expression>,
        src_ref: SrcRef,
    },
    UnaryOp {
        op: String,
        rhs: Box<Expression>,
        src_ref: SrcRef,
    },
    ArrayElementAccess(Box<Expression>, Box<Expression>, SrcRef),
    PropertyAccess(Box<Expression>, Identifier, SrcRef),
    AttributeAccess(Box<Expression>, Identifier, SrcRef),
    MethodCall(Box<Expression>, MethodCall, SrcRef),
}

Any expression.

Variants

Invalid

Something went wrong (and an error will be reported)

Literal(Literal)

An integer, float, color or bool literal: 1, 1.0, #00FF00, false

FormatString(FormatString)

A string that contains format expressions: “value = {a}”

ArrayExpression(ArrayExpression)

A list: [a, b, c]

TupleExpression(TupleExpression)

A tuple: (a, b, c)

Body(Body)

A body: {}.

Call(Call)

A call: ops::subtract().

QualifiedName(QualifiedName)

A qualified name: foo::bar.

Marker(Marker)

A marker expression: @input.

BinaryOp

A binary operation: a + b

Fields

lhs: Box<Expression>

Left-hand side

op: String

Operator (‘+’, ‘-’, ‘/’, ‘*’, ‘<’, ‘>’, ‘≤’, ‘≥’, ‘&’, ‘|’)

rhs: Box<Expression>

Right -hand side

src_ref: SrcRef

Source code reference

UnaryOp

A unary operation: !a

Fields

op: String

Operator (‘+’, ‘-’, ‘!’)

rhs: Box<Expression>

Right -hand side

src_ref: SrcRef

Source code reference

ArrayElementAccess(Box<Expression>, Box<Expression>, SrcRef)

Access an element of a list (a[0]) or a tuple (a.0 or a.b)

PropertyAccess(Box<Expression>, Identifier, SrcRef)

Access an element of a tuple: a.b.

AttributeAccess(Box<Expression>, Identifier, SrcRef)

Access an attribute of a model: a#b.

MethodCall(Box<Expression>, MethodCall, SrcRef)

Call to a method: [2,3].len() First expression must evaluate to a value

Implementations

impl Expression

pub fn eval_with_attribute_list( &self, attribute_list: &AttributeList, context: &mut EvalContext, ) -> EvalResult<Value>

Evaluate an expression together with an attribute list.

The attribute list will be also evaluated and the resulting attributes will be assigned to the resulting value.

impl Expression

pub fn literal_from_str(s: &str) -> ParseResult<Self>

Generate literal from string

impl Expression

pub fn single_identifier(&self) -> Option<&Identifier>

If the expression consists of a single identifier, e.g. a

Trait Implementations

impl AsRef<Expression> for Expression

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

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 Default for Expression

fn default() -> Expression

Returns the “default value” for a type.

impl Display for Expression

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

Formats the value using the given formatter.

impl Eval<Option<Model>> for Expression

fn eval(&self, context: &mut EvalContext) -> EvalResult<Option<Model>>

Evaluate a syntax element into a type T.

impl Eval for Expression

fn eval(&self, context: &mut EvalContext) -> EvalResult<Value>

Evaluate a syntax element into a type T.

impl Parse for Expression

fn parse(pair: Pair<'_>) -> ParseResult<Self>

impl PartialEq for Expression

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

fn src_ref(&self) -> SrcRef

Return source code reference.

fn source_hash(&self) -> u64

Return source code hash.

impl TreeDisplay for Expression

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

Write item into f and use {:depth$} syntax in front of your single line output to get proper indention.

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

Display as tree starting at depth 0.

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

Display as tree starting at given depth in debug mode

fn write_tree(&self, f: &mut impl Write) -> Result<()>

Display as tree starting at depth 0 into a file