Struct arcon::weld::ast::prelude::Expr

pub struct Expr {
    pub ty: Type,
    pub kind: ExprKind,
    pub annotations: Annotations,
}

A typed Weld expression tree.

Fields

ty: Type

kind: ExprKind

annotations: Annotations

Methods

impl Expr

pub fn children(&self) -> IntoIter<&Expr>

Get an iterator for the children of this expression.

pub fn children_mut(&mut self) -> IntoIter<&mut Expr>

Get an iterator of mutable references to the children of this expression.

pub fn partially_typed(&self) -> bool

Returns whether this Expr is partially typed.

A type is partial if it or any of its subtypes is Unknown.

pub fn substitute(&mut self, symbol: &Symbol, replacement: &Expr)

Substitute Ident nodes with the given symbol for another expression, stopping when an expression in the tree redefines the symbol (e.g. Let or Lambda parameters).

pub fn traverse<F>(&self, func: &mut F) where
    F: FnMut(&Expr), 

Run a closure on this expression and every child, in pre-order.

pub fn contains_symbol(&self, sym: &Symbol) -> bool

Returns true if this expression contains the symbol sym in an Ident.

pub fn transform_and_continue<F>(&mut self, func: &mut F) where
    F: FnMut(&mut Expr) -> (Option<Expr>, bool), 

Recursively transforms an expression in place by running a function on it and optionally replacing it with another expression.

pub fn transform_and_continue_res<F>(&mut self, func: &mut F) where
    F: FnMut(&mut Expr) -> Result<(Option<Expr>, bool), WeldCompileError>, 

Recursively transforms an expression in place by running a function on it and optionally replacing it with another expression. Supports returning an error, which is treated as returning (None, false)

pub fn transform<F>(&mut self, func: &mut F) where
    F: FnMut(&mut Expr) -> Option<Expr>, 

Recursively transforms an expression in place by running a function on it and optionally replacing it with another expression.

pub fn transform_up<F>(&mut self, func: &mut F) where
    F: FnMut(&mut Expr) -> Option<Expr>, 

Recursively transforms an expression in place by running a function first on its children, then on the root expression itself; this can be more efficient than transform for some cases

pub fn transform_kind<F>(&mut self, func: &mut F) where
    F: FnMut(&mut Expr) -> Option<ExprKind>, 

Transform an expression by replacing its kind with another ExprKind.

The type of the expression is unmodified.

pub fn contains(&self, other: &Expr) -> bool

Returns true if this expressions contains other.

Trait Implementations

impl HashIgnoringSymbols for Expr

fn hash_ignoring_symbols(&self) -> Result<u64, WeldCompileError>

Hash an AST ignoring symbol names.

impl Eq for Expr

impl Takeable for Expr

fn take(&mut self) -> Expr

impl Placeholder for Expr

fn is_placeholder(&self) -> bool

Returns whether this expression is a placeholder.

fn new_placeholder() -> Expr

Create a new placeholder.

impl PartialEq<Expr> for Expr

fn eq(&self, other: &Expr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Expr) -> bool

This method tests for !=.

impl NewExpr for Expr

fn new(kind: ExprKind) -> Result<Expr, WeldCompileError>

Creates a new expression with the given kind.

fn new_with_type(kind: ExprKind, ty: Type) -> Result<Expr, WeldCompileError>

Creates new expression with the given kind and type.

fn new_literal(kind: LiteralKind) -> Result<Expr, WeldCompileError>

Creates a new literal expression.

fn new_ident(symbol: Symbol, ty: Type) -> Result<Expr, WeldCompileError>

Creates a new typed identifier expression.

fn new_bin_op(
    kind: BinOpKind,
    left: Expr,
    right: Expr
) -> Result<Expr, WeldCompileError>

Creates a new binary operator expression.

fn new_unary_op(
    kind: UnaryOpKind,
    value: Expr
) -> Result<Expr, WeldCompileError>

Creates a new unary operator expression.

fn new_cast(kind: ScalarKind, expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new cast operator expression.

fn new_negate(expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new negation operator expression.

fn new_not(expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new not operator expression.

fn new_broadcast(expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new scalar to SIMD broadcast expression.

fn new_to_vec(expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new dictionary to vector expression.

fn new_make_struct(exprs: Vec<Expr>) -> Result<Expr, WeldCompileError>

Creates a new struct literal expression.

fn new_make_vector(exprs: Vec<Expr>) -> Result<Expr, WeldCompileError>

Creates a new vector literal expression.

fn new_make_vector_typed(
    exprs: Vec<Expr>,
    ty: Type
) -> Result<Expr, WeldCompileError>

Creates a new typed vector literal expression.

fn new_get_field(expr: Expr, index: u32) -> Result<Expr, WeldCompileError>

Creates a new field access expression on struct.

fn new_length(expr: Expr) -> Result<Expr, WeldCompileError>

Creates a new vector length expression.

fn new_lookup(data: Expr, index: Expr) -> Result<Expr, WeldCompileError>

Creates a new vector or dictionary lookup expression.

fn new_opt_lookup(data: Expr, index: Expr) -> Result<Expr, WeldCompileError>

Creates a new dictionary optional lookup expression.

fn new_key_exists(data: Expr, key: Expr) -> Result<Expr, WeldCompileError>

Creates a new dictionary key exists expression.

fn new_slice(
    data: Expr,
    index: Expr,
    size: Expr
) -> Result<Expr, WeldCompileError>

Creates a new vector slicing expression.

fn new_sort(data: Expr, cmpfunc: Expr) -> Result<Expr, WeldCompileError>

Creates a new vector sort expression.

fn new_let(
    name: Symbol,
    value: Expr,
    body: Expr
) -> Result<Expr, WeldCompileError>

Creates a new let expression.

fn new_if(
    cond: Expr,
    on_true: Expr,
    on_false: Expr
) -> Result<Expr, WeldCompileError>

Creates a new if expression.

fn new_select(
    cond: Expr,
    on_true: Expr,
    on_false: Expr
) -> Result<Expr, WeldCompileError>

Creates a new select expression.

fn new_lambda(
    params: Vec<Parameter>,
    body: Expr
) -> Result<Expr, WeldCompileError>

Creates a new lambda expression.

fn new_apply(func: Expr, params: Vec<Expr>) -> Result<Expr, WeldCompileError>

Creates a new apply expression.

fn new_cudf(
    sym_name: String,
    args: Vec<Expr>,
    return_ty: Type
) -> Result<Expr, WeldCompileError>

Creates a new CUDF expression.

fn new_new_builder(
    kind: BuilderKind,
    expr: Option<Expr>
) -> Result<Expr, WeldCompileError>

Creates a builder initialization expression.

fn new_for(
    iters: Vec<Iter>,
    builder: Expr,
    func: Expr
) -> Result<Expr, WeldCompileError>

Creates a new parallel for loop expression.

fn new_merge(builder: Expr, value: Expr) -> Result<Expr, WeldCompileError>

Creates a new merge expression.

fn new_result(builder: Expr) -> Result<Expr, WeldCompileError>

Creates a new result expression.

fn new_serialize(value: Expr) -> Result<Expr, WeldCompileError>

Creates a new serialize expression.

fn new_deserialize(value: Expr, ty: Type) -> Result<Expr, WeldCompileError>

Creates a new deserialize expression.

impl PrettyPrint for Expr

fn pretty_print(&self) -> String

Pretty print an expression.

fn pretty_print_config(&self, config: &PrettyPrintConfig) -> String

Pretty print an expression with the given configuration.

impl Debug for Expr

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

Formats the value using the given formatter.

impl CompareIgnoringSymbols for Expr

fn compare_ignoring_symbols(
    &self,
    other: &Expr
) -> Result<bool, WeldCompileError>

Compare this expression to other.

impl InferTypes for Expr

fn infer_types(&mut self) -> Result<(), WeldCompileError>

Checks and infers types in place.

fn infer_local(&mut self) -> Result<(), WeldCompileError>

Locally check and infer types.

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

fn uniquify(&mut self) -> Result<(), WeldCompileError>

Modifies an expression to make symbol names unique.

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, 

Feeds a slice of this type into the given [Hasher].