Enum Expression

pub enum Expression<'src> {
    And {
        lhs: Box<Expression<'src>>,
        rhs: Box<Expression<'src>>,
    },
    Assert {
        condition: Condition<'src>,
        error: Box<Expression<'src>>,
    },
    Backtick {
        contents: String,
        token: Token<'src>,
    },
    Call {
        thunk: Thunk<'src>,
    },
    Concatenation {
        lhs: Box<Expression<'src>>,
        rhs: Box<Expression<'src>>,
    },
    Conditional {
        condition: Condition<'src>,
        then: Box<Expression<'src>>,
        otherwise: Box<Expression<'src>>,
    },
    Group {
        contents: Box<Expression<'src>>,
    },
    Join {
        lhs: Option<Box<Expression<'src>>>,
        rhs: Box<Expression<'src>>,
    },
    Or {
        lhs: Box<Expression<'src>>,
        rhs: Box<Expression<'src>>,
    },
    StringLiteral {
        string_literal: StringLiteral<'src>,
    },
    Variable {
        name: Name<'src>,
    },
}

An expression. Note that the Just language grammar has both an expression production of additions (a + b) and values, and a value production of all other value types (for example strings, function calls, and parenthetical groups).

The parser parses both values and expressions into Expressions.

Variants

And

lhs && rhs

Fields

lhs: Box<Expression<'src>>

rhs: Box<Expression<'src>>

Assert

assert(condition, error)

Fields

condition: Condition<'src>

error: Box<Expression<'src>>

Backtick

contents

Fields

contents: String

token: Token<'src>

Call

name(arguments)

Fields

thunk: Thunk<'src>

Concatenation

lhs + rhs

Fields

lhs: Box<Expression<'src>>

rhs: Box<Expression<'src>>

Conditional

if condition { then } else { otherwise }

Fields

condition: Condition<'src>

then: Box<Expression<'src>>

otherwise: Box<Expression<'src>>

Group

(contents)

Fields

contents: Box<Expression<'src>>

Join

lhs / rhs

Fields

lhs: Option<Box<Expression<'src>>>

rhs: Box<Expression<'src>>

Or

lhs || rhs

Fields

lhs: Box<Expression<'src>>

rhs: Box<Expression<'src>>

StringLiteral

"string_literal" or 'string_literal'

Fields

string_literal: StringLiteral<'src>

Variable

variable

Fields

name: Name<'src>

Implementations

impl<'src> Expression<'src>

pub fn variables<'expression>(&'expression self) -> Variables<'expression, 'src>

Trait Implementations

impl<'src> Clone for Expression<'src>

fn clone(&self) -> Expression<'src>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'src> Debug for Expression<'src>

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

Formats the value using the given formatter.

impl<'src> Display for Expression<'src>

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

Formats the value using the given formatter.

impl<'src> PartialEq for Expression<'src>

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'src> StructuralPartialEq for Expression<'src>