Enum muse_lang::compiler::syntax::Expression

pub enum Expression {
    RootModule,
    Literal(Literal),
    Lookup(Box<Lookup>),
    If(Box<IfExpression>),
    Match(Box<MatchExpression>),
    Try(Box<TryExpression>),
    TryOrNil(Box<TryOrNil>),
    Throw(Box<ThrowExpression>),
    Map(Box<MapExpression>),
    List(Box<ListExpression>),
    Call(Box<FunctionCall>),
    Index(Box<Index>),
    Assign(Box<Assignment>),
    Unary(Box<UnaryExpression>),
    Binary(Box<BinaryExpression>),
    Block(Box<Block>),
    Loop(Box<LoopExpression>),
    Break(Box<BreakExpression>),
    Continue(Box<ContinueExpression>),
    Return(Box<ReturnExpression>),
    Module(Box<ModuleDefinition>),
    Function(Box<FunctionDefinition>),
    Structure(Box<StructureDefinition>),
    StructureLiteral(Box<NewStruct>),
    Enum(Box<EnumDefinition>),
    SingleMatch(Box<SingleMatch>),
    Macro(Box<MacroInvocation>),
    InfixMacro(Box<InfixMacroInvocation>),
    Group(Box<Enclosed<Ranged<Expression>>>),
    FormatString(Box<Delimited<Ranged<Symbol>, Ranged<Expression>>>),
}

A Muse expression.

Variants

RootModule

A reference to the root module ($).

Literal(Literal)

A literal value.

Lookup(Box<Lookup>)

A lookup of a field by a name (a.b).

If(Box<IfExpression>)

Conditional expression evaluation.

Match(Box<MatchExpression>)

A pattern match expression.

Try(Box<TryExpression>)

A try/catch expression.

TryOrNil(Box<TryOrNil>)

A try-or-nil expression (?).

Throw(Box<ThrowExpression>)

A throw expression.

Map(Box<MapExpression>)

A map literal.

List(Box<ListExpression>)

A list literal.

Call(Box<FunctionCall>)

A function invocation (a(b)).

Index(Box<Index>)

An indexing expression (a[b])

Assign(Box<Assignment>)

An assignment expression (a = b)

Unary(Box<UnaryExpression>)

An expression with a single expression argument.

Binary(Box<BinaryExpression>)

An expression with two expression arguments.

Block(Box<Block>)

A scoped, sequence of expressions.

Loop(Box<LoopExpression>)

A loop expression.

Break(Box<BreakExpression>)

A break control flow expression.

Continue(Box<ContinueExpression>)

A continue control flow expression.

Return(Box<ReturnExpression>)

A return control flow expression.

Module(Box<ModuleDefinition>)

A module declaration.

Function(Box<FunctionDefinition>)

A function declaration.

Structure(Box<StructureDefinition>)

A structure definition.

StructureLiteral(Box<NewStruct>)

A structure literal.

Enum(Box<EnumDefinition>)

An enum definition.

SingleMatch(Box<SingleMatch>)

A variable declaration.

Macro(Box<MacroInvocation>)

A macro invocation.

InfixMacro(Box<InfixMacroInvocation>)

An infix macro invocation.

Group(Box<Enclosed<Ranged<Expression>>>)

A grouped expression ((a)).

FormatString(Box<Delimited<Ranged<Symbol>, Ranged<Expression>>>)

A format string expression (f"hello {name}").

Implementations

impl Expression

pub fn chain( expressions: Vec<Ranged<Expression>>, semicolons: Vec<Ranged<Token>>, ) -> Ranged<Self>

Converts a list of expressions into a chain expression, delimited by semicolons.

If semicolons does not contain enough delimiters, new ones will be manufactured with a range that sits between the end of the previous expression and the start of the next.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy 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() -> Self

Returns the “default value” for a type.

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

fn tokenize_ranged( &self, range: SourceRange, tokens: &mut VecDeque<Ranged<Token>>, )

Tokenize self into tokens within the enclosing range.

impl StructuralPartialEq for Expression