Enum Expr

Source

pub enum Expr {
Show 41 variants
    Ident(Ident),
    StringLiteral(StringLiteral),
    BacktickLiteral {
        span: Span,
        value: String,
    },
    NumberLiteral {
        span: Span,
        value: String,
    },
    BoolLiteral {
        span: Span,
        value: bool,
    },
    Null {
        span: Span,
    },
    Now {
        span: Span,
    },
    This {
        span: Span,
    },
    Within {
        span: Span,
    },
    DurationLiteral {
        span: Span,
        value: String,
    },
    SetLiteral {
        span: Span,
        elements: Vec<Expr>,
    },
    ObjectLiteral {
        span: Span,
        fields: Vec<NamedArg>,
    },
    GenericType {
        span: Span,
        name: Box<Expr>,
        args: Vec<Expr>,
    },
    MemberAccess {
        span: Span,
        object: Box<Expr>,
        field: Ident,
    },
    OptionalAccess {
        span: Span,
        object: Box<Expr>,
        field: Ident,
    },
    NullCoalesce {
        span: Span,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Call {
        span: Span,
        function: Box<Expr>,
        args: Vec<CallArg>,
    },
    JoinLookup {
        span: Span,
        entity: Box<Expr>,
        fields: Vec<JoinField>,
    },
    BinaryOp {
        span: Span,
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    Comparison {
        span: Span,
        left: Box<Expr>,
        op: ComparisonOp,
        right: Box<Expr>,
    },
    LogicalOp {
        span: Span,
        left: Box<Expr>,
        op: LogicalOp,
        right: Box<Expr>,
    },
    Not {
        span: Span,
        operand: Box<Expr>,
    },
    In {
        span: Span,
        element: Box<Expr>,
        collection: Box<Expr>,
    },
    NotIn {
        span: Span,
        element: Box<Expr>,
        collection: Box<Expr>,
    },
    Exists {
        span: Span,
        operand: Box<Expr>,
    },
    NotExists {
        span: Span,
        operand: Box<Expr>,
    },
    Where {
        span: Span,
        source: Box<Expr>,
        condition: Box<Expr>,
    },
    With {
        span: Span,
        source: Box<Expr>,
        predicate: Box<Expr>,
    },
    Pipe {
        span: Span,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Lambda {
        span: Span,
        param: Box<Expr>,
        body: Box<Expr>,
    },
    Conditional {
        span: Span,
        branches: Vec<CondBranch>,
        else_body: Option<Box<Expr>>,
    },
    For {
        span: Span,
        binding: ForBinding,
        collection: Box<Expr>,
        filter: Option<Box<Expr>>,
        body: Box<Expr>,
    },
    ProjectionMap {
        span: Span,
        source: Box<Expr>,
        field: Ident,
    },
    TransitionsTo {
        span: Span,
        subject: Box<Expr>,
        new_state: Box<Expr>,
    },
    Becomes {
        span: Span,
        subject: Box<Expr>,
        new_state: Box<Expr>,
    },
    Binding {
        span: Span,
        name: Ident,
        value: Box<Expr>,
    },
    WhenGuard {
        span: Span,
        action: Box<Expr>,
        condition: Box<Expr>,
    },
    TypeOptional {
        span: Span,
        inner: Box<Expr>,
    },
    LetExpr {
        span: Span,
        name: Ident,
        value: Box<Expr>,
    },
    QualifiedName(QualifiedName),
    Block {
        span: Span,
        items: Vec<Expr>,
    },
}