Enum FSharpExpr 

pub enum FSharpExpr {
    Lit(String),
    Var(String),
    App(Box<FSharpExpr>, Box<FSharpExpr>),
    Lambda(String, Box<FSharpExpr>),
    MultiLambda(Vec<String>, Box<FSharpExpr>),
    Let(String, Box<FSharpExpr>, Box<FSharpExpr>),
    LetRec(String, Box<FSharpExpr>, Box<FSharpExpr>),
    Match(Box<FSharpExpr>, Vec<(FSharpPattern, FSharpExpr)>),
    If(Box<FSharpExpr>, Box<FSharpExpr>, Box<FSharpExpr>),
    Tuple(Vec<FSharpExpr>),
    FsList(Vec<FSharpExpr>),
    FsArray(Vec<FSharpExpr>),
    BinOp(String, Box<FSharpExpr>, Box<FSharpExpr>),
    UnaryOp(String, Box<FSharpExpr>),
    Record(Vec<(String, FSharpExpr)>),
    RecordUpdate(Box<FSharpExpr>, Vec<(String, FSharpExpr)>),
    FieldAccess(Box<FSharpExpr>, String),
    Seq(Box<FSharpExpr>, Box<FSharpExpr>),
    Ann(Box<FSharpExpr>, FSharpType),
    Pipe(Box<FSharpExpr>, Box<FSharpExpr>),
    Ctor(String, Vec<FSharpExpr>),
    Do(Vec<FSharpExpr>),
    Raw(String),
}

An F# expression node.

Variants

Lit(String)

Literal source (integer, float, string, bool, unit ())

Var(String)

Variable / identifier reference

App(Box<FSharpExpr>, Box<FSharpExpr>)

Function application: f x

Lambda(String, Box<FSharpExpr>)

Lambda: fun param -> body

MultiLambda(Vec<String>, Box<FSharpExpr>)

Multi-parameter lambda: fun a b c -> body

Let(String, Box<FSharpExpr>, Box<FSharpExpr>)

Let binding: let name = value in body

LetRec(String, Box<FSharpExpr>, Box<FSharpExpr>)

Recursive let binding: let rec name = value in body

Match(Box<FSharpExpr>, Vec<(FSharpPattern, FSharpExpr)>)

Pattern match: match expr with | pat -> branch

If(Box<FSharpExpr>, Box<FSharpExpr>, Box<FSharpExpr>)

If-then-else

Tuple(Vec<FSharpExpr>)

Tuple construction: (a, b, c)

FsList(Vec<FSharpExpr>)

List literal: [a; b; c]

FsArray(Vec<FSharpExpr>)

Array literal: [| a; b; c |]

BinOp(String, Box<FSharpExpr>, Box<FSharpExpr>)

Binary operator: lhs op rhs

UnaryOp(String, Box<FSharpExpr>)

Unary operator: op expr

Record(Vec<(String, FSharpExpr)>)

Record construction: { field1 = v1; field2 = v2 }

RecordUpdate(Box<FSharpExpr>, Vec<(String, FSharpExpr)>)

Record update: { base with field = v }

FieldAccess(Box<FSharpExpr>, String)

Field access: expr.Field

Seq(Box<FSharpExpr>, Box<FSharpExpr>)

Sequence: expr1; expr2 (semicolon-separated, result is expr2)

Ann(Box<FSharpExpr>, FSharpType)

Type annotation: (expr : T)

Pipe(Box<FSharpExpr>, Box<FSharpExpr>)

Pipe forward: expr |> f

Ctor(String, Vec<FSharpExpr>)

Constructor application: Some x, MyCase(a, b)

Do(Vec<FSharpExpr>)

do { ... } computation expression (simplified)

Raw(String)

Raw source snippet (escape hatch)

Trait Implementations

impl Clone for FSharpExpr

fn clone(&self) -> FSharpExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FSharpExpr

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

Formats the value using the given formatter.