Enum Expr 

pub enum Expr {
    Literal(Lit),
    Ident(String),
    IdentFnSubCall(FullIdent),
    PrefixOp {
        op: TokenKind,
        expr: Box<Expr>,
    },
    InfixOp {
        op: TokenKind,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    New(String),
    FnApplication {
        callee: Box<Expr>,
        args: Vec<Option<Expr>>,
    },
    WithScoped,
    MemberExpression {
        base: Box<Expr>,
        property: String,
    },
}

Variants

Literal(Lit)

Ident(String)

IdentFnSubCall(FullIdent)

An identifier, identifier with array access, sub or function call This grammar is ambiguous, so will need to be resolved at runtime TODO we can probably make a different type for

• Ident without array access or SubCall without args
• Ident with array access or FnCall with args or
• FnCall without args
• SubCall with args

PrefixOp

Fields

op: TokenKind

expr: Box<Expr>

InfixOp

Fields

op: TokenKind

lhs: Box<Expr>

rhs: Box<Expr>

New(String)

FnApplication

Fields

callee: Box<Expr>

args: Vec<Option<Expr>>

WithScoped

MemberExpression

Fields

base: Box<Expr>

property: String

Implementations

impl Expr

pub fn ident2(name: impl Into<String>) -> Self

pub fn ident(name: impl Into<String>) -> Self

pub fn int(i: isize) -> Self

pub fn int_str(i: impl Into<String>) -> Self

pub fn bool(b: bool) -> Self

pub fn str(s: impl Into<String>) -> Self

pub fn new(name: impl Into<String>) -> Self

pub fn member(base: Expr, property: impl Into<String>) -> Self

pub fn fn_application(callee: Expr, args: Vec<Expr>) -> Self

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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