Enum ExprKind 

pub enum ExprKind {
    NoOp,
    Constant(Value),
    Module {
        name: ArcStr,
        value: ModuleKind,
    },
    ExplicitParens(Arc<Expr>),
    Do {
        exprs: Arc<[Expr]>,
    },
    Use {
        name: ModPath,
    },
    Bind(Arc<BindExpr>),
    Ref {
        name: ModPath,
    },
    Connect {
        name: ModPath,
        value: Arc<Expr>,
        deref: bool,
    },
    StringInterpolate {
        args: Arc<[Expr]>,
    },
    StructRef {
        source: Arc<Expr>,
        field: ArcStr,
    },
    TupleRef {
        source: Arc<Expr>,
        field: usize,
    },
    ArrayRef {
        source: Arc<Expr>,
        i: Arc<Expr>,
    },
    ArraySlice {
        source: Arc<Expr>,
        start: Option<Arc<Expr>>,
        end: Option<Arc<Expr>>,
    },
    MapRef {
        source: Arc<Expr>,
        key: Arc<Expr>,
    },
    StructWith(StructWithExpr),
    Lambda(Arc<LambdaExpr>),
    TypeDef(TypeDefExpr),
    TypeCast {
        expr: Arc<Expr>,
        typ: Type,
    },
    Apply(ApplyExpr),
    Any {
        args: Arc<[Expr]>,
    },
    Array {
        args: Arc<[Expr]>,
    },
    Map {
        args: Arc<[(Expr, Expr)]>,
    },
    Tuple {
        args: Arc<[Expr]>,
    },
    Variant {
        tag: ArcStr,
        args: Arc<[Expr]>,
    },
    Struct(StructExpr),
    Select(SelectExpr),
    Qop(Arc<Expr>),
    OrNever(Arc<Expr>),
    TryCatch(Arc<TryCatchExpr>),
    ByRef(Arc<Expr>),
    Deref(Arc<Expr>),
    Eq {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Ne {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Lt {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Gt {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Lte {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Gte {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    And {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Or {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Not {
        expr: Arc<Expr>,
    },
    Add {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Sub {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Mul {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Div {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Mod {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
    Sample {
        lhs: Arc<Expr>,
        rhs: Arc<Expr>,
    },
}

Variants

NoOp

Constant(Value)

Module

Fields

name: ArcStr

value: ModuleKind

ExplicitParens(Arc<Expr>)

Do

Fields

exprs: Arc<[Expr]>

Use

Fields

name: ModPath

Bind(Arc<BindExpr>)

Ref

Fields

name: ModPath

Connect

Fields

name: ModPath

value: Arc<Expr>

deref: bool

StringInterpolate

Fields

args: Arc<[Expr]>

StructRef

Fields

source: Arc<Expr>

field: ArcStr

TupleRef

Fields

source: Arc<Expr>

field: usize

ArrayRef

Fields

source: Arc<Expr>

i: Arc<Expr>

ArraySlice

Fields

source: Arc<Expr>

start: Option<Arc<Expr>>

end: Option<Arc<Expr>>

MapRef

Fields

source: Arc<Expr>

key: Arc<Expr>

StructWith(StructWithExpr)

Lambda(Arc<LambdaExpr>)

TypeDef(TypeDefExpr)

TypeCast

Fields

expr: Arc<Expr>

typ: Type

Apply(ApplyExpr)

Any

Fields

args: Arc<[Expr]>

Array

Fields

args: Arc<[Expr]>

Map

Fields

args: Arc<[(Expr, Expr)]>

Tuple

Fields

args: Arc<[Expr]>

Variant

Fields

tag: ArcStr

args: Arc<[Expr]>

Struct(StructExpr)

Select(SelectExpr)

Qop(Arc<Expr>)

OrNever(Arc<Expr>)

TryCatch(Arc<TryCatchExpr>)

ByRef(Arc<Expr>)

Deref(Arc<Expr>)

Eq

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Ne

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Lt

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Gt

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Lte

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Gte

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

And

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Or

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Not

Fields

expr: Arc<Expr>

Add

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Sub

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Mul

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Div

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Mod

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Sample

Fields

lhs: Arc<Expr>

rhs: Arc<Expr>

Implementations

impl ExprKind

pub fn to_expr(self, pos: SourcePosition) -> Expr

pub fn to_expr_nopos(self) -> Expr

does not provide any position information or comment

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl Display for ExprKind

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

Formats the value using the given formatter.

impl PartialEq for ExprKind

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

fn partial_cmp(&self, other: &ExprKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PrettyDisplay for ExprKind

fn fmt_pretty_inner(&self, buf: &mut PrettyBuf) -> Result

Do the actual pretty print. This should not be called directly, it will be called by fmt_pretty when we know it can’t fit on a single line.

fn fmt_pretty(&self, buf: &mut PrettyBuf) -> Result

This is the user facing fmt method, it will first try to format the expression on a single line, and if that is impossible it will call the pretty printer.

fn to_string_pretty(&self, limit: usize) -> LPooled<String>

Pretty print to a pooled string

impl StructuralPartialEq for ExprKind