Enum Expr 

pub enum Expr {
    And(ExprAnd),
    Any(ExprAny),
    Arg(ExprArg),
    BinaryOp(ExprBinaryOp),
    Cast(ExprCast),
    Default,
    Error(ExprError),
    Exists(ExprExists),
    Func(ExprFunc),
    InList(ExprInList),
    InSubquery(ExprInSubquery),
    IsNull(ExprIsNull),
    IsVariant(ExprIsVariant),
    Let(ExprLet),
    Map(ExprMap),
    Match(ExprMatch),
    Not(ExprNot),
    Or(ExprOr),
    Project(ExprProject),
    Record(ExprRecord),
    Reference(ExprReference),
    List(ExprList),
    Stmt(ExprStmt),
    Value(Value),
}

An expression node in Toasty’s query AST.

Expr is the central type in the statement intermediate representation. Every filter, projection, value, and computed result in a Toasty query is represented as an Expr tree. The query engine compiles these trees through several phases (simplify, lower, plan, execute) before they reach a database driver.

Examples

use toasty_core::stmt::{Expr, Value};

// Constant value expressions
let t = Expr::TRUE;
assert!(t.is_true());

let n = Expr::null();
assert!(n.is_value_null());

// From conversions
let i: Expr = 42i64.into();
assert!(i.is_value());

Variants

And(ExprAnd)

Logical AND of multiple expressions. See ExprAnd.

Any(ExprAny)

Returns true if any item in a collection is truthy. See ExprAny.

Arg(ExprArg)

Positional argument placeholder. See ExprArg.

BinaryOp(ExprBinaryOp)

Binary comparison or arithmetic operation. See ExprBinaryOp.

Cast(ExprCast)

Type cast. See ExprCast.

Default

Instructs the database to use its default value for a column. Useful for auto-increment fields and other columns with server-side defaults.

Error(ExprError)

An error expression that fails evaluation with a message. See ExprError.

Exists(ExprExists)

[NOT] EXISTS(SELECT ...) check. See ExprExists.

Func(ExprFunc)

Aggregate or scalar function call. See ExprFunc.

InList(ExprInList)

expr IN (list) membership test. See ExprInList.

InSubquery(ExprInSubquery)

expr IN (SELECT ...) membership test. See ExprInSubquery.

IsNull(ExprIsNull)

IS [NOT] NULL check. Separate from binary operators because of three-valued logic semantics in SQL. See ExprIsNull.

IsVariant(ExprIsVariant)

Tests whether a value is a specific enum variant. See ExprIsVariant.

Let(ExprLet)

Scoped binding expression (transient – inlined before planning). See ExprLet.

Map(ExprMap)

Applies a transformation to each item in a collection. See ExprMap.

Match(ExprMatch)

Pattern-match dispatching on a subject. See ExprMatch.

Not(ExprNot)

Boolean negation. See ExprNot.

Or(ExprOr)

Logical OR of multiple expressions. See ExprOr.

Project(ExprProject)

Field projection from a composite value. See ExprProject.

Record(ExprRecord)

Fixed-size heterogeneous tuple of expressions. See ExprRecord.

Reference(ExprReference)

Reference to a field, column, or model in the current or an outer query scope. See ExprReference.

List(ExprList)

Ordered, homogeneous collection of expressions. See ExprList.

Stmt(ExprStmt)

Embedded sub-statement (e.g., a subquery). See ExprStmt.

Value(Value)

Constant value. See Value.

Implementations

impl Expr

pub fn eval(&self, input: impl Input) -> Result<Value>

Evaluates this expression using the provided Input for argument and reference resolution.

pub fn eval_bool(&self, input: impl Input) -> Result<bool>

Evaluates this expression and returns the result as a bool.

Errors

Returns an error if the expression does not evaluate to a boolean.

pub fn eval_const(&self) -> Result<Value>

Evaluates this expression as a constant (no external input).

impl Expr

pub const TRUE: Expr

The boolean true constant expression.

pub const FALSE: Expr

The boolean false constant expression.

pub const DEFAULT: Expr = Expr::Default

Alias for Expr::Default as a constant.

pub fn null() -> Self

Creates a null value expression.

pub fn is_value_null(&self) -> bool

Is a value that evaluates to null

pub fn is_true(&self) -> bool

Returns true if the expression is the true boolean expression

pub fn is_false(&self) -> bool

Returns true if the expression is the false boolean expression

pub fn is_unsatisfiable(&self) -> bool

Returns true if the expression can never evaluate to true.

In SQL’s three-valued logic, both false and null are unsatisfiable: a filter producing either value will never match any rows.

pub fn is_default(&self) -> bool

Returns true if the expression is the default expression

pub fn is_value(&self) -> bool

Returns true if the expression is a constant value.

pub fn is_stmt(&self) -> bool

Returns true if the expression is a sub-statement.

pub fn is_binary_op(&self) -> bool

Returns true if the expression is a binary operation

pub fn is_arg(&self) -> bool

Returns true if the expression is an argument placeholder.

pub fn is_always_non_nullable(&self) -> bool

Returns true if the expression is always non-nullable.

This method is conservative and only returns true for expressions we can prove are non-nullable.

pub fn into_value(self) -> Value

Consumes the expression and returns the inner Value.

Panics

Panics (via todo!()) if self is not an Expr::Value.

pub fn into_stmt(self) -> ExprStmt

Consumes the expression and returns the inner ExprStmt.

Panics

Panics (via todo!()) if self is not an Expr::Stmt.

pub fn is_stable(&self) -> bool

Returns true if the expression is stable

An expression is stable if it yields the same value each time it is evaluated

pub fn is_const(&self) -> bool

Returns true if the expression is a constant expression.

A constant expression is one that does not reference any external data. This means it contains no Reference, Stmt, or Arg expressions that reference external inputs.

Arg expressions inside Map bodies with nesting less than the current map depth are local bindings (bound to the mapped element), not external inputs, and are therefore considered const in that context.

pub fn is_eval(&self) -> bool

Returns true if the expression can be evaluated.

An expression can be evaluated if it doesn’t contain references to external data sources like subqueries or references. Args are allowed since they represent function parameters that can be bound at evaluation time.

pub fn map_projections(&self, f: impl FnMut(&Projection) -> Projection) -> Self

Returns a clone of this expression with all Projection nodes transformed by f.

pub fn entry(&self, path: impl EntryPath) -> Option<Entry<'_>>

Navigates into a nested record or list expression by path and returns a read-only Entry reference.

Returns None if the path cannot be followed (e.g., the expression is not a record or list at the expected depth).

pub fn entry_mut(&mut self, path: impl EntryPath) -> EntryMut<'_>

Navigates into a nested record or list expression by path and returns a mutable EntryMut reference.

Panics

Panics if the path cannot be followed on the current expression shape.

pub fn take(&mut self) -> Self

Takes the expression out, leaving Expr::Value(Value::Null) in its place. Equivalent to std::mem::replace(self, Expr::null()).

pub fn substitute(&mut self, input: impl Input)

Replaces every ExprArg in this expression tree with the corresponding value from input.

impl Expr

pub fn and(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates an AND expression from two operands.

Flattens nested ANDs: and(and(a, b), c) produces and(a, b, c). Short-circuits on true: and(true, x) returns x.

pub fn and_from_vec(operands: Vec<Self>) -> Self

Creates an AND expression from a vector of operands.

Returns Expr::Value(true) for an empty vector and unwraps single-element vectors into the element itself.

impl Expr

pub fn any(expr: impl Into<Expr>) -> Self

Creates an Any expression that returns true if any item in the list evaluates to true.

Returns false if the list is empty (matching Rust’s [].iter().any() semantics).

pub fn is_any(&self) -> bool

Returns true if this is an Any expression

impl Expr

pub fn arg(expr_arg: impl Into<ExprArg>) -> Self

Creates an argument expression from a value convertible to ExprArg.

A usize can be passed directly: Expr::arg(0) creates arg(position=0, nesting=0).

impl Expr

pub fn binary_op( lhs: impl Into<Self>, op: BinaryOp, rhs: impl Into<Self>, ) -> Self

Creates a binary operation expression with the given operator.

pub fn eq(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates an equality (==) expression.

pub fn is_eq(&self) -> bool

Returns true if the expression is a binary expression with the equality operator

pub fn ge(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates a greater-than-or-equal (>=) expression.

pub fn gt(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates a greater-than (>) expression.

pub fn le(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates a less-than-or-equal (<=) expression.

pub fn lt(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates a less-than (<) expression.

pub fn ne(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates a not-equal (!=) expression.

impl Expr

pub fn cast(expr: impl Into<Self>, ty: impl Into<Type>) -> Self

Creates a type cast expression that converts expr to the target type.

pub fn is_cast(&self) -> bool

Returns true if this expression is a type cast.

impl Expr

pub fn error(message: impl Into<String>) -> Self

Creates an error expression with the given message.

If this expression is ever evaluated at runtime, it will fail with the provided message.

impl Expr

pub fn exists(subquery: impl Into<Query>) -> Expr

Creates an EXISTS(subquery) expression.

pub fn not_exists(subquery: impl Into<Query>) -> Expr

Creates a NOT EXISTS(subquery) expression.

impl Expr

pub fn in_list(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates an IN list expression: lhs IN rhs.

impl Expr

pub fn in_subquery(lhs: impl Into<Self>, rhs: impl Into<Query>) -> Self

Creates an IN (subquery) expression: lhs IN (SELECT ...).

pub fn is_in_subquery(&self) -> bool

Returns true if this expression is an IN (subquery) check.

impl Expr

pub fn is_null(expr: impl Into<Self>) -> Self

Creates an IS NULL expression.

pub fn is_not_null(expr: impl Into<Self>) -> Self

Creates an IS NOT NULL expression (equivalent to NOT(IS NULL(expr))).

impl Expr

pub fn is_variant(expr: impl Into<Self>, variant: VariantId) -> Self

Creates a variant check expression testing whether expr is the given variant.

impl Expr

pub fn list<T>(items: impl IntoIterator<Item = T>) -> Self

where T: Into<Self>,

Creates a list expression from an iterator of items convertible to Expr.

pub fn list_from_vec(items: Vec<Self>) -> Self

Creates a list expression from a pre-built vector of expressions.

pub fn is_list(&self) -> bool

Returns true if this expression is a list (either Expr::List or Expr::Value(Value::List(...))).

pub fn is_list_empty(&self) -> bool

Returns true if this expression is an empty list.

pub fn as_list_unwrap(&self) -> &ExprList

Returns a reference to the inner ExprList.

Panics

Panics if self is not Expr::List.

pub fn as_list_mut_unwrap(&mut self) -> &mut ExprList

Returns a mutable reference to the inner ExprList.

Panics

Panics if self is not Expr::List.

pub fn into_list(self) -> Option<ExprList>

Consumes the expression, returning Some(ExprList) if it is a list, or None otherwise.

impl Expr

pub fn map(base: impl Into<Self>, map: impl Into<Self>) -> Self

Creates a map expression that applies map to each element of base.

pub fn as_map(&self) -> Option<&ExprMap>

Returns a reference to the inner ExprMap if this is a map expression, or None otherwise.

pub fn as_map_unwrap(&self) -> &ExprMap

Returns a reference to the inner ExprMap.

Panics

Panics if self is not Expr::Map.

impl Expr

pub fn match_expr( subject: impl Into<Self>, arms: Vec<MatchArm>, else_expr: impl Into<Self>, ) -> Self

Creates a Match expression that dispatches on subject.

impl Expr

pub fn not(expr: impl Into<Self>) -> Self

Creates a Not expression that negates the given expression.

pub fn is_not(&self) -> bool

Returns true if this is a Not expression.

impl Expr

pub fn or(lhs: impl Into<Self>, rhs: impl Into<Self>) -> Self

Creates an OR expression from two operands.

Flattens nested ORs: or(or(a, b), c) produces or(a, b, c).

pub fn or_from_vec(operands: Vec<Self>) -> Self

Creates an OR expression from a vector of operands.

Returns Expr::Value(false) for an empty vector and unwraps single-element vectors into the element itself.

impl Expr

pub fn project(base: impl Into<Self>, projection: impl Into<Projection>) -> Self

Creates a projection expression that extracts a field from base using the given projection path.

pub fn arg_project( expr_arg: impl Into<ExprArg>, projection: impl Into<Projection>, ) -> Self

Shorthand for Expr::project(Expr::arg(expr_arg), projection).

pub fn is_project(&self) -> bool

Returns true if this expression is a projection.

pub fn as_project(&self) -> Option<&ExprProject>

Returns a reference to the inner ExprProject if this is a projection, or None otherwise.

pub fn as_project_unwrap(&self) -> &ExprProject

Returns a reference to the inner ExprProject.

Panics

Panics if self is not Expr::Project.

impl Expr

pub fn record<T>(items: impl IntoIterator<Item = T>) -> Self

where T: Into<Self>,

Creates a record expression from an iterator of items convertible to Expr.

pub fn record_from_vec(fields: Vec<Self>) -> Self

Creates a record expression from a pre-built vector of field expressions.

pub fn is_record(&self) -> bool

Returns true if this expression is a record.

pub fn as_record(&self) -> Option<&ExprRecord>

Returns a reference to the inner ExprRecord if this is a record, or None otherwise.

pub fn as_record_unwrap(&self) -> &ExprRecord

Returns a reference to the inner ExprRecord.

Panics

Panics if self is not Expr::Record.

pub fn as_record_mut(&mut self) -> Option<&mut ExprRecord>

Returns a mutable reference to the inner ExprRecord if this is a record, or None otherwise.

pub fn as_record_mut_unwrap(&mut self) -> &mut ExprRecord

Returns a mutable reference to the inner ExprRecord.

Panics

Panics if self is not Expr::Record.

pub fn into_record(self) -> ExprRecord

Consumes the expression and returns the inner ExprRecord.

Panics

Panics if self is not Expr::Record.

pub fn record_len(&self) -> Option<usize>

Returns the number of fields if this expression is a record (either Expr::Record or Expr::Value(Value::Record(...))), or None otherwise.

pub fn into_record_items(self) -> Option<impl Iterator<Item = Expr>>

Consumes the expression and returns an iterator over the record’s fields if this is a record expression or value, or None otherwise.

impl Expr

pub fn is_expr_reference(&self) -> bool

Returns true if this expression is a reference (field, column, or model).

pub fn ref_self_field(field: impl Into<FieldId>) -> Self

Creates an expression that references a field in the current query.

This creates an ExprReference::Field with nesting = 0, meaning it references a field in the current query scope rather than an outer query.

Arguments

• field - A field identifier that can be converted into a FieldId

Returns

An Expr::Reference containing an ExprReference::Field that points to the specified field in the current query’s relation.

pub fn ref_field(nesting: usize, field: impl Into<FieldId>) -> Self

Create a reference to a field at a specified nesting level

pub fn ref_parent_field(field: impl Into<FieldId>) -> Self

Create a reference to a field one level up

pub fn is_field(&self) -> bool

Returns true if this is a field reference.

pub fn ref_parent_model() -> Self

Creates a model reference to the parent (nesting level 1).

pub fn ref_ancestor_model(nesting: usize) -> Self

Create a model reference to the specified nesting level

pub fn column(column: impl Into<ExprReference>) -> Self

Creates a column reference expression.

pub fn is_column(&self) -> bool

Returns true if this expression is a column reference.

pub fn as_expr_reference(&self) -> Option<&ExprReference>

Returns a reference to the inner ExprReference if this is a reference expression, or None otherwise.

pub fn as_expr_reference_unwrap(&self) -> &ExprReference

Returns a reference to the inner ExprReference.

Panics

Panics if self is not Expr::Reference.

pub fn as_expr_column(&self) -> Option<&ExprColumn>

Returns a reference to the inner ExprColumn if this is a column reference, or None otherwise.

pub fn as_expr_column_unwrap(&self) -> &ExprColumn

Returns a reference to the inner ExprColumn.

Panics

Panics if self is not Expr::Reference(ExprReference::Column(_)).

impl Expr

pub fn stmt(stmt: impl Into<Statement>) -> Self

Creates a sub-statement expression from any value convertible to Statement.

impl Expr

pub fn count_star() -> Self

Creates a COUNT(*) expression.

impl Expr

pub fn last_insert_id() -> Self

Creates a LAST_INSERT_ID() function 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.

impl<'a> From<&'a Expr> for Entry<'a>

fn from(value: &'a Expr) -> Self

Converts to this type from the input type.

impl From<&ExprColumn> for Expr

fn from(value: &ExprColumn) -> Self

Converts to this type from the input type.

impl From<&ExprReference> for Expr

fn from(value: &ExprReference) -> Self

Converts to this type from the input type.

impl From<&String> for Expr

fn from(value: &String) -> Self

Converts to this type from the input type.

impl From<&i64> for Expr

fn from(value: &i64) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut Expr> for EntryMut<'a>

fn from(value: &'a mut Expr) -> Self

Converts to this type from the input type.

impl From<&str> for Expr

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<E1, E2> From<(E1, E2)> for Expr

where E1: Into<Self>, E2: Into<Self>,

fn from(value: (E1, E2)) -> Self

Converts to this type from the input type.

impl<'a> From<Entry<'a>> for Expr

fn from(value: Entry<'a>) -> Self

Converts to this type from the input type.

impl From<Expr> for Returning

fn from(value: Expr) -> Self

Converts to this type from the input type.

impl From<Expr> for Values

fn from(value: Expr) -> Self

Converts to this type from the input type.

impl From<ExprAnd> for Expr

fn from(value: ExprAnd) -> Self

Converts to this type from the input type.

impl From<ExprAny> for Expr

fn from(value: ExprAny) -> Self

Converts to this type from the input type.

impl From<ExprArg> for Expr

fn from(value: ExprArg) -> Self

Converts to this type from the input type.

impl From<ExprBinaryOp> for Expr

fn from(value: ExprBinaryOp) -> Self

Converts to this type from the input type.

impl From<ExprCast> for Expr

fn from(value: ExprCast) -> Self

Converts to this type from the input type.

impl From<ExprColumn> for Expr

fn from(value: ExprColumn) -> Self

Converts to this type from the input type.

impl From<ExprError> for Expr

fn from(value: ExprError) -> Self

Converts to this type from the input type.

impl From<ExprExists> for Expr

fn from(value: ExprExists) -> Self

Converts to this type from the input type.

impl From<ExprFunc> for Expr

fn from(value: ExprFunc) -> Self

Converts to this type from the input type.

impl From<ExprInList> for Expr

fn from(value: ExprInList) -> Self

Converts to this type from the input type.

impl From<ExprInSubquery> for Expr

fn from(value: ExprInSubquery) -> Self

Converts to this type from the input type.

impl From<ExprIsNull> for Expr

fn from(value: ExprIsNull) -> Self

Converts to this type from the input type.

impl From<ExprIsVariant> for Expr

fn from(value: ExprIsVariant) -> Self

Converts to this type from the input type.

impl From<ExprLet> for Expr

fn from(value: ExprLet) -> Self

Converts to this type from the input type.

impl From<ExprList> for Expr

fn from(value: ExprList) -> Self

Converts to this type from the input type.

impl From<ExprMap> for Expr

fn from(value: ExprMap) -> Self

Converts to this type from the input type.

impl From<ExprMatch> for Expr

fn from(value: ExprMatch) -> Self

Converts to this type from the input type.

impl From<ExprNot> for Expr

fn from(value: ExprNot) -> Self

Converts to this type from the input type.

impl From<ExprOr> for Expr

fn from(value: ExprOr) -> Self

Converts to this type from the input type.

impl From<ExprProject> for Expr

fn from(value: ExprProject) -> Self

Converts to this type from the input type.

impl From<ExprRecord> for Expr

fn from(value: ExprRecord) -> Self

Converts to this type from the input type.

impl From<ExprReference> for Expr

fn from(value: ExprReference) -> Self

Converts to this type from the input type.

impl From<ExprStmt> for Expr

fn from(value: ExprStmt) -> Self

Converts to this type from the input type.

impl From<FuncCount> for Expr

fn from(value: FuncCount) -> Self

Converts to this type from the input type.

impl From<FuncLastInsertId> for Expr

fn from(value: FuncLastInsertId) -> Self

Converts to this type from the input type.

impl From<Insert> for Expr

fn from(value: Insert) -> Self

Converts to this type from the input type.

impl From<String> for Expr

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Value> for Expr

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<Vec<Expr>> for Expr

fn from(value: Vec<Self>) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<i64> for Expr

fn from(value: i64) -> Self

Converts to this type from the input type.

impl Like<&[Value]> for Expr

fn like(&self, other: &&[Value]) -> bool

Returns true if self matches the pattern other.

impl Like<&[u8]> for Expr

fn like(&self, pattern: &&[u8]) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<&[u8; N]> for Expr

fn like(&self, other: &&[u8; N]) -> bool

Returns true if self matches the pattern other.

impl Like<&String> for Expr

fn like(&self, pattern: &&String) -> bool

Returns true if self matches the pattern other.

impl Like<&str> for Expr

fn like(&self, pattern: &&str) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<[&str; N]> for Expr

fn like(&self, other: &[&str; N]) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<[Value; N]> for Expr

Like implementation for expressions against arrays of Values

fn like(&self, pattern: &[Value; N]) -> bool

Returns true if self matches the pattern other.

impl<T1> Like<(T1,)> for Expr

where Expr: Like<T1>,

fn like(&self, pattern: &(T1,)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2> Like<(T1, T2)> for Expr

where Expr: Like<T1> + Like<T2>,

fn like(&self, pattern: &(T1, T2)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3> Like<(T1, T2, T3)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3>,

fn like(&self, pattern: &(T1, T2, T3)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4> Like<(T1, T2, T3, T4)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4>,

fn like(&self, pattern: &(T1, T2, T3, T4)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5> Like<(T1, T2, T3, T4, T5)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6> Like<(T1, T2, T3, T4, T5, T6)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7> Like<(T1, T2, T3, T4, T5, T6, T7)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8> Like<(T1, T2, T3, T4, T5, T6, T7, T8)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11> + Like<T12>,

fn like( &self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> bool

Returns true if self matches the pattern other.

impl Like<String> for Expr

Like implementation for Expr and String (delegates to PartialEq)

fn like(&self, pattern: &String) -> bool

Returns true if self matches the pattern other.

impl Like<Uuid> for Expr

fn like(&self, other: &Uuid) -> bool

Returns true if self matches the pattern other.

impl Like<Value> for Expr

fn like(&self, other: &Value) -> bool

Returns true if self matches the pattern other.

impl Like<Vec<Value>> for Expr

Like implementation for expressions against Vec patterns

fn like(&self, pattern: &Vec<Value>) -> bool

Returns true if self matches the pattern other.

impl Like<i16> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i16) -> bool

Returns true if self matches the pattern other.

impl Like<i32> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i32) -> bool

Returns true if self matches the pattern other.

impl Like<i64> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i64) -> bool

Returns true if self matches the pattern other.

impl Like<i8> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i8) -> bool

Returns true if self matches the pattern other.

impl Like<isize> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &isize) -> bool

Returns true if self matches the pattern other.

impl Like<u16> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u16) -> bool

Returns true if self matches the pattern other.

impl Like<u32> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u32) -> bool

Returns true if self matches the pattern other.

impl Like<u64> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u64) -> bool

Returns true if self matches the pattern other.

impl Like<u8> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u8) -> bool

Returns true if self matches the pattern other.

impl Like<usize> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &usize) -> bool

Returns true if self matches the pattern other.

impl Node for Expr

fn visit<V: Visit>(&self, visit: V)

Traverses this node with an immutable visitor.

fn visit_mut<V: VisitMut>(&mut self, visit: V)

Traverses this node with a mutable visitor.

impl PartialEq<&str> for Expr

PartialEq<&str> for Expr

fn eq(&self, other: &&str) -> 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<T0> PartialEq<(T0,)> for Expr

where Expr: PartialEq<T0>, Value: PartialEq<T0>,

fn eq(&self, other: &(T0,)) -> 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<T0, T1> PartialEq<(T0, T1)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1>, Value: PartialEq<T0> + PartialEq<T1>,

fn eq(&self, other: &(T0, T1)) -> 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<T0, T1, T2> PartialEq<(T0, T1, T2)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2>,

fn eq(&self, other: &(T0, T1, T2)) -> 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<T0, T1, T2, T3> PartialEq<(T0, T1, T2, T3)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3>,

fn eq(&self, other: &(T0, T1, T2, T3)) -> 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<T0, T1, T2, T3, T4> PartialEq<(T0, T1, T2, T3, T4)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4>,

fn eq(&self, other: &(T0, T1, T2, T3, T4)) -> 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<T0, T1, T2, T3, T4, T5> PartialEq<(T0, T1, T2, T3, T4, T5)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5)) -> 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<T0, T1, T2, T3, T4, T5, T6> PartialEq<(T0, T1, T2, T3, T4, T5, T6)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10> + PartialEq<T11>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10> + PartialEq<T11>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> 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<T0> PartialEq<Expr> for (T0,)

where Expr: PartialEq<(T0,)>,

fn eq(&self, other: &Expr) -> 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<T0, T1> PartialEq<Expr> for (T0, T1)

where Expr: PartialEq<(T0, T1)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2> PartialEq<Expr> for (T0, T1, T2)

where Expr: PartialEq<(T0, T1, T2)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3> PartialEq<Expr> for (T0, T1, T2, T3)

where Expr: PartialEq<(T0, T1, T2, T3)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4> PartialEq<Expr> for (T0, T1, T2, T3, T4)

where Expr: PartialEq<(T0, T1, T2, T3, T4)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>,

fn eq(&self, other: &Expr) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>,

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for i16

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for i32

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for i64

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for i8

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for u16

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for u32

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for u64

fn eq(&self, other: &Expr) -> 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 PartialEq<Expr> for u8

fn eq(&self, other: &Expr) -> 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 PartialEq<String> for Expr

PartialEq for Expr

fn eq(&self, other: &String) -> 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 PartialEq<bool> for Expr

PartialEq implementation for Expr and primitive type

fn eq(&self, other: &bool) -> 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 PartialEq<i16> for Expr

fn eq(&self, other: &i16) -> 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 PartialEq<i32> for Expr

fn eq(&self, other: &i32) -> 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 PartialEq<i64> for Expr

fn eq(&self, other: &i64) -> 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 PartialEq<i8> for Expr

fn eq(&self, other: &i8) -> 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 PartialEq<str> for Expr

PartialEq for Expr

fn eq(&self, other: &str) -> 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 PartialEq<u16> for Expr

fn eq(&self, other: &u16) -> 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 PartialEq<u32> for Expr

fn eq(&self, other: &u32) -> 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 PartialEq<u64> for Expr

fn eq(&self, other: &u64) -> 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 PartialEq<u8> for Expr

fn eq(&self, other: &u8) -> 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 PartialEq for Expr

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

fn project(self, projection: &Projection) -> Option<Expr>

Applies the projection and returns the resulting expression.

impl Project for Expr

fn project(self, projection: &Projection) -> Option<Expr>

Applies the projection and returns the resulting expression.

impl StructuralPartialEq for Expr