Enum Expr 

pub enum Expr {
    Var(Ident, Span),
    QualVar(ModuleName, Ident, Span),
    Con(Ident, Span),
    QualCon(ModuleName, Ident, Span),
    Lit(Lit, Span),
    App(Box<Expr>, Box<Expr>, Span),
    Lam(Vec<Pat>, Box<Expr>, Span),
    Let(Vec<Decl>, Box<Expr>, Span),
    If(Box<Expr>, Box<Expr>, Box<Expr>, Span),
    Case(Box<Expr>, Vec<Alt>, Span),
    Do(Vec<Stmt>, Span),
    Tuple(Vec<Expr>, Span),
    List(Vec<Expr>, Span),
    ArithSeq(ArithSeq, Span),
    ListComp(Box<Expr>, Vec<Stmt>, Span),
    RecordCon(Ident, Vec<FieldBind>, bool, Span),
    QualRecordCon(ModuleName, Ident, Vec<FieldBind>, bool, Span),
    RecordUpd(Box<Expr>, Vec<FieldBind>, Span),
    Infix(Box<Expr>, Ident, Box<Expr>, Span),
    Neg(Box<Expr>, Span),
    Paren(Box<Expr>, Span),
    Ann(Box<Expr>, Type, Span),
    TypeApp(Box<Expr>, Type, Span),
    Lazy(Box<Expr>, Span),
    Wildcard(Span),
}

An expression.

Variants

Var(Ident, Span)

Variable: x

QualVar(ModuleName, Ident, Span)

Qualified variable: M.foo, Data.List.sort

Con(Ident, Span)

Constructor: Just

QualCon(ModuleName, Ident, Span)

Qualified constructor: M.Just, Data.Maybe.Nothing

Lit(Lit, Span)

Literal: 42, "hello"

App(Box<Expr>, Box<Expr>, Span)

Application: f x

Lam(Vec<Pat>, Box<Expr>, Span)

Lambda: \x -> x

Let(Vec<Decl>, Box<Expr>, Span)

Let: let x = 1 in x

If(Box<Expr>, Box<Expr>, Box<Expr>, Span)

If: if c then t else e

Case(Box<Expr>, Vec<Alt>, Span)

Case: case x of { ... }

Do(Vec<Stmt>, Span)

Do block: do { ... }

Tuple(Vec<Expr>, Span)

Tuple: (a, b, c)

List(Vec<Expr>, Span)

List: [1, 2, 3]

ArithSeq(ArithSeq, Span)

Arithmetic sequence: [1..10], [1,3..10]

ListComp(Box<Expr>, Vec<Stmt>, Span)

List comprehension: [x | x <- xs, x > 0]

RecordCon(Ident, Vec<FieldBind>, bool, Span)

Record construction: Foo { bar = 1 } or Foo { bar = 1, .. } (RecordWildCards)

QualRecordCon(ModuleName, Ident, Vec<FieldBind>, bool, Span)

Qualified record construction: M.Foo { bar = 1 }

RecordUpd(Box<Expr>, Vec<FieldBind>, Span)

Record update: foo { bar = 1 }

Infix(Box<Expr>, Ident, Box<Expr>, Span)

Infix operator: a + b

Neg(Box<Expr>, Span)

Negation: -x

Paren(Box<Expr>, Span)

Parenthesized expression

Ann(Box<Expr>, Type, Span)

Type annotation: x :: Int

TypeApp(Box<Expr>, Type, Span)

Explicit type application: f @Int

Lazy(Box<Expr>, Span)

Lazy block (H26): lazy { ... }

Wildcard(Span)

Wildcard/hole: _ (used in patterns parsed as expressions)

Implementations

impl Expr

pub fn span(&self) -> Span

Get the span of this expression.

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.