Enum Expr

pub enum Expr {
    Block(Interned<Vec<Expr>>),
    Array(Interned<ArgsExpr>),
    Dict(Interned<ArgsExpr>),
    Args(Interned<ArgsExpr>),
    Pattern(Interned<Pattern>),
    Element(Interned<ElementExpr>),
    Unary(Interned<UnInst<Expr>>),
    Binary(Interned<BinInst<Expr>>),
    Apply(Interned<ApplyExpr>),
    Func(Interned<FuncExpr>),
    Let(Interned<LetExpr>),
    Show(Interned<ShowExpr>),
    Set(Interned<SetExpr>),
    Ref(Interned<RefExpr>),
    ContentRef(Interned<ContentRefExpr>),
    Select(Interned<SelectExpr>),
    Import(Interned<ImportExpr>),
    Include(Interned<IncludeExpr>),
    Contextual(Interned<Expr>),
    Conditional(Interned<IfExpr>),
    WhileLoop(Interned<WhileExpr>),
    ForLoop(Interned<ForExpr>),
    Type(Ty),
    Decl(Interned<Decl>),
    Star,
}

Variants

Block(Interned<Vec<Expr>>)

A sequence of expressions

Array(Interned<ArgsExpr>)

An array literal

Dict(Interned<ArgsExpr>)

A dict literal

Args(Interned<ArgsExpr>)

An args literal

Pattern(Interned<Pattern>)

A pattern

Element(Interned<ElementExpr>)

An element literal

Unary(Interned<UnInst<Expr>>)

An unary operation

Binary(Interned<BinInst<Expr>>)

A binary operation

Apply(Interned<ApplyExpr>)

A function call

Func(Interned<FuncExpr>)

A function

Let(Interned<LetExpr>)

A let

Show(Interned<ShowExpr>)

A show

Set(Interned<SetExpr>)

A set

Ref(Interned<RefExpr>)

A reference

ContentRef(Interned<ContentRefExpr>)

A content reference

Select(Interned<SelectExpr>)

A select

Import(Interned<ImportExpr>)

An import

Include(Interned<IncludeExpr>)

An include

Contextual(Interned<Expr>)

A contextual

Conditional(Interned<IfExpr>)

A conditional

WhileLoop(Interned<WhileExpr>)

A while loop

ForLoop(Interned<ForExpr>)

A for loop

Type(Ty)

A type

Decl(Interned<Decl>)

A declaration

Star

A star import

Implementations

impl Expr

pub fn repr(&self) -> EcoString

pub fn span(&self) -> Span

pub fn file_id(&self) -> Option<FileId>

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl From<Decl> for Expr

fn from(decl: Decl) -> Expr

Converts to this type from the input type.

impl From<Interned<Decl>> for Expr

fn from(decl: Interned<Decl>) -> Expr

Converts to this type from the input type.

impl Hash for Expr

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Internable for Expr

fn storage() -> &'static InternStorage<Expr>

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 Eq for Expr

impl StructuralPartialEq for Expr