pub enum MirScalarExpr {
    Column(usize),
    Literal(Result<Row, EvalError>, ColumnType),
    CallUnmaterializable(UnmaterializableFunc),
    CallUnary {
        func: UnaryFunc,
        expr: Box<MirScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<MirScalarExpr>,
        expr2: Box<MirScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<MirScalarExpr>,
    },
    If {
        cond: Box<MirScalarExpr>,
        then: Box<MirScalarExpr>,
        els: Box<MirScalarExpr>,
    },
}

Variants§

§

Column(usize)

A column of the input row

§

Literal(Result<Row, EvalError>, ColumnType)

A literal value. (Stored as a row, because we can’t own a Datum)

§

CallUnmaterializable(UnmaterializableFunc)

A call to an unmaterializable function.

These functions cannot be evaluated by MirScalarExpr::eval. They must be transformed away by a higher layer.

§

CallUnary

Fields

A function call that takes one expression as an argument.

§

CallBinary

A function call that takes two expressions as arguments.

§

CallVariadic

A function call that takes an arbitrary number of arguments.

§

If

Conditionally evaluated expressions.

It is important that then and els only be evaluated if cond is true or not, respectively. This is the only way users can guard execution (other logical operator do not short-circuit) and we need to preserve that.

Implementations§

source§

impl MirScalarExpr

source

pub fn columns(is: &[usize]) -> Vec<MirScalarExpr>

source

pub fn column(column: usize) -> Self

source

pub fn literal(res: Result<Datum<'_>, EvalError>, typ: ScalarType) -> Self

source

pub fn literal_ok(datum: Datum<'_>, typ: ScalarType) -> Self

source

pub fn literal_null(typ: ScalarType) -> Self

source

pub fn literal_false() -> Self

source

pub fn literal_true() -> Self

source

pub fn call_unary(self, func: UnaryFunc) -> Self

source

pub fn call_binary(self, other: Self, func: BinaryFunc) -> Self

source

pub fn if_then_else(self, t: Self, f: Self) -> Self

source

pub fn or(self, other: Self) -> Self

source

pub fn and(self, other: Self) -> Self

source

pub fn not(self) -> Self

source

pub fn call_is_null(self) -> Self

source

pub fn and_or_args(&self, func_to_match: VariadicFunc) -> Vec<MirScalarExpr>

Match AND or OR on self and get the args. If no match, then interpret self as if it were wrapped in a 1-arg AND/OR.

source

pub fn expr_eq_literal(&self, expr: &MirScalarExpr) -> Option<(Row, bool)>

Try to match a literal equality involving the given expression on one side. Return the (non-null) literal and a bool that indicates whether an inversion was needed.

More specifically: If self is an equality with a null literal on any side, then the match fails! Otherwise: for a given expr, if self is <expr> = <literal> or <literal> = <expr> then return Some((<literal>, false)). In addition to just trying to match <expr> as it is, we also try to remove an invertible function call (such as a cast). If the match succeeds with the inversion, then return Some((<inverted-literal>, true)). For more details on the inversion, see invert_casts_on_expr_eq_literal_inner.

source

fn expr_eq_literal_inner( expr_to_match: &MirScalarExpr, literal: Row, literal_expr: &MirScalarExpr, other_side: &MirScalarExpr ) -> Option<(Row, bool)>

source

pub fn any_expr_eq_literal(&self) -> Option<MirScalarExpr>

If self is <expr> = <literal> or <literal> = <expr> then return <expr>. It also tries to remove a cast (or other invertible function call) from <expr> before returning it, see invert_casts_on_expr_eq_literal_inner.

source

pub fn invert_casts_on_expr_eq_literal(&self) -> MirScalarExpr

If the given MirScalarExpr is a literal equality where one side is an invertible function call, then calls the inverse function on both sides of the equality and returns the modified version of the given MirScalarExpr. Otherwise, it returns the original expression. For more details, see invert_casts_on_expr_eq_literal_inner.

source

fn invert_casts_on_expr_eq_literal_inner( expr: &MirScalarExpr, literal: &MirScalarExpr ) -> (MirScalarExpr, MirScalarExpr)

Given an <expr> and a <literal> that were taken out from <expr> = <literal> or <literal> = <expr>, it tries to simplify the equality by applying the inverse function of the outermost function call of <expr> (if exists):

<literal> = func(<inner_expr>), where func is invertible –> <func^-1(literal)> = <inner_expr> if func^-1(literal) doesn’t error out, and both func and func^-1 preserve uniqueness.

The return value is the <inner_expr> and the literal value that we get by applying the inverse function.

source

pub fn impossible_literal_equality_because_types(&self) -> bool

Tries to remove a cast (or other invertible function) in the same way as invert_casts_on_expr_eq_literal, but if calling the inverse function fails on the literal, then it deems the equality to be impossible. For example if a is a smallint column, then it catches a::integer = 1000000 to be an always false predicate (where the ::integer could have been inserted implicitly).

source

fn impossible_literal_equality_because_types_inner( literal: &MirScalarExpr, other_side: &MirScalarExpr ) -> bool

source

pub fn any_expr_ineq_literal(&self) -> bool

Determines if self is <expr> < <literal> or <expr> > <literal> or <literal> < <expr> or <literal> > <expr> or <expr> <= <literal> or <expr> >= <literal> or <literal> <= <expr> or <literal> >= <expr>.

source

pub fn permute(&mut self, permutation: &[usize])

Rewrites column indices with their value in permutation.

This method is applicable even when permutation is not a strict permutation, and it only needs to have entries for each column referenced in self.

source

pub fn permute_map(&mut self, permutation: &BTreeMap<usize, usize>)

Rewrites column indices with their value in permutation.

This method is applicable even when permutation is not a strict permutation, and it only needs to have entries for each column referenced in self.

source

pub fn support(&self) -> BTreeSet<usize>

source

pub fn support_into(&self, support: &mut BTreeSet<usize>)

source

pub fn take(&mut self) -> Self

source

pub fn as_literal(&self) -> Option<Result<Datum<'_>, &EvalError>>

source

pub fn as_literal_owned(&self) -> Option<Result<Row, EvalError>>

source

pub fn as_literal_str(&self) -> Option<&str>

source

pub fn as_literal_int64(&self) -> Option<i64>

source

pub fn as_literal_err(&self) -> Option<&EvalError>

source

pub fn is_literal(&self) -> bool

source

pub fn is_literal_true(&self) -> bool

source

pub fn is_literal_false(&self) -> bool

source

pub fn is_literal_null(&self) -> bool

source

pub fn is_literal_ok(&self) -> bool

source

pub fn is_literal_err(&self) -> bool

source

pub fn is_column(&self) -> bool

source

pub fn is_error_if_null(&self) -> bool

source

pub fn contains_error_if_null(&self) -> bool

👎Deprecated: Use might_error instead
source

pub fn might_error(&self) -> bool

A very crude approximation for scalar expressions that might produce an error.

Currently, this is restricted only to expressions that either contain a literal error or a VariadicFunc::ErrorIfNull call.

source

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

If self is a column, return the column index, otherwise None.

source

pub fn reduce(&mut self, column_types: &[ColumnType])

Reduces a complex expression where possible.

Also canonicalizes the expression.

use mz_expr::MirScalarExpr;
use mz_repr::{ColumnType, Datum, ScalarType};

let expr_0 = MirScalarExpr::Column(0);
let expr_t = MirScalarExpr::literal_ok(Datum::True, ScalarType::Bool);
let expr_f = MirScalarExpr::literal_ok(Datum::False, ScalarType::Bool);

let mut test =
expr_t
    .clone()
    .and(expr_f.clone())
    .if_then_else(expr_0, expr_t.clone());

let input_type = vec![ScalarType::Int32.nullable(false)];
test.reduce(&input_type);
assert_eq!(test, expr_t);
source

fn decompose_is_null(&mut self) -> Option<MirScalarExpr>

Decompose an IsNull expression into a disjunction of simpler expressions.

Assumes that self is the expression inside of an IsNull. Returns Some(expressions) if the outer IsNull is to be replaced by some other expression. Note: if it returns None, it might still have mutated *self.

source

pub fn flatten_associative(&mut self)

Flattens a chain of calls to associative variadic functions (For example: ORs or ANDs)

source

fn reduce_and_canonicalize_and_or(&mut self)

Canonicalizes AND/OR, and does some straightforward simplifications

source

fn demorgans(&mut self)

Transforms !(a && b) into !a || !b, and !(a || b) into !a && !b

source

fn undistribute_and_or(&mut self)

AND/OR undistribution (factoring out) to apply at each MirScalarExpr.

This method attempts to apply one of the distribution laws (in a direction opposite to the their name):

(a && b) || (a && c) --> a && (b || c)  // Undistribute-OR
(a || b) && (a || c) --> a || (b && c)  // Undistribute-AND

or one of their corresponding two absorption law special cases:

a || (a && c)  -->  a  // Absorb-OR
a && (a || c)  -->  a  // Absorb-AND

The method also works with more than 2 arguments at the top, e.g.

(a && b) || (a && c) || (a && d)  -->  a && (b || c || d)

It can also factor out only a subset of the top arguments, e.g.

(a && b) || (a && c) || (d && e)  -->  (a && (b || c)) || (d && e)

Note that sometimes there are two overlapping possibilities to factor out from, e.g.

(a && b) || (a && c) || (d && c)

Here we can factor out a from from the 1. and 2. terms, or we can factor out c from the 2. and 3. terms. One of these might lead to more/better undistribution opportunities later, but we just pick one locally, because recursively trying out all of them would lead to exponential run time.

The local heuristic is that we prefer a candidate that leads to an absorption, or if there is no such one then we simply pick the first. In case of multiple absorption candidates, it doesn’t matter which one we pick, because applying an absorption cannot adversely effect the possibility of applying other absorptions.

Assumption

Assumes that nested chains of AND/OR applications are flattened (this can be enforced with Self::flatten_associative).

Examples

Absorb-OR:

a || (a && c) || (a && d)
-->
a && (true || c || d)
-->
a && true
-->
a

Here only the first step is performed by this method. The rest is done by Self::reduce_and_canonicalize_and_or called after us in reduce().

source

pub fn non_null_requirements(&self, columns: &mut BTreeSet<usize>)

Adds any columns that must be non-Null for self to be non-Null.

source

pub fn typ(&self, column_types: &[ColumnType]) -> ColumnType

source

pub fn eval<'a>( &'a self, datums: &[Datum<'a>], temp_storage: &'a RowArena ) -> Result<Datum<'a>, EvalError>

source

pub fn contains_temporal(&self) -> bool

True iff the expression contains UnmaterializableFunc::MzNow.

source

pub fn contains_unmaterializable(&self) -> bool

True iff the expression contains an UnmaterializableFunc.

source

pub fn contains_unmaterializable_except( &self, exceptions: &[UnmaterializableFunc] ) -> bool

True iff the expression contains an UnmaterializableFunc that is not in the exceptions list.

source

pub fn contains_column(&self) -> bool

True iff the expression contains a Column.

source

pub fn size(&self) -> usize

The size of the expression as a tree.

source§

impl MirScalarExpr

source

pub fn could_error(&self) -> bool

True iff evaluation could possibly error on non-error input Datum.

source§

impl MirScalarExpr

source

pub fn children(&self) -> impl DoubleEndedIterator<Item = &Self>

Iterates through references to child expressions.

source

pub fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Self>

Iterates through mutable references to child expressions.

source

pub fn visit_pre<F>(&self, f: F)where F: FnMut(&Self),

Visits all subexpressions in DFS preorder.

source

pub fn visit_pre_mut<F: FnMut(&mut Self)>(&mut self, f: F)

Iterative pre-order visitor.

source§

impl MirScalarExpr

source

pub fn format( &self, f: &mut Formatter<'_>, cols: Option<&Vec<String>> ) -> Result

Trait Implementations§

source§

impl Arbitrary for MirScalarExpr

§

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.
§

type Strategy = BoxedStrategy<MirScalarExpr>

The type of Strategy used to generate values of type Self.
source§

fn arbitrary_with(_: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args. Read more
source§

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). Read more
source§

impl Clone for MirScalarExpr

source§

fn clone(&self) -> MirScalarExpr

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for MirScalarExpr

source§

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

Formats the value using the given formatter. Read more
source§

impl<'de> Deserialize<'de> for MirScalarExpr

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for MirScalarExpr

source§

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

Formats the value using the given formatter. Read more
source§

impl Hash for MirScalarExpr

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MzReflect for MirScalarExpr

source§

fn add_to_reflected_type_info(rti: &mut ReflectedTypeInfo)

Adds names and types of the fields of the struct or enum to rti. Read more
source§

impl Ord for MirScalarExpr

source§

fn cmp(&self, other: &MirScalarExpr) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for MirScalarExpr

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for MirScalarExpr

source§

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

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl RustType<ProtoMirScalarExpr> for MirScalarExpr

source§

fn into_proto(&self) -> ProtoMirScalarExpr

Convert a Self into a Proto value.
source§

fn from_proto(proto: ProtoMirScalarExpr) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value. Read more
source§

impl ScalarOps for MirScalarExpr

source§

fn match_col_ref(&self) -> Option<usize>

source§

fn references(&self, column: usize) -> bool

source§

impl Serialize for MirScalarExpr

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl VisitChildren<MirScalarExpr> for MirScalarExpr

source§

fn visit_children<F>(&self, f: F)where F: FnMut(&Self),

Apply an infallible immutable function f to each direct child.
source§

fn visit_mut_children<F>(&mut self, f: F)where F: FnMut(&mut Self),

Apply an infallible mutable function f to each direct child.
source§

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>where F: FnMut(&Self) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child. Read more
source§

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>where F: FnMut(&mut Self) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child. Read more
source§

impl Eq for MirScalarExpr

source§

impl StructuralEq for MirScalarExpr

source§

impl StructuralPartialEq for MirScalarExpr

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T, U> CastInto<U> for Twhere U: CastFrom<T>,

source§

fn cast_into(self) -> U

Performs the cast.
source§

impl<Q, K> Comparable<K> for Qwhere Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn compare(&self, key: &K) -> Ordering

Compare self to key and return their ordering.
source§

impl<T> DynClone for Twhere T: Clone,

source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> FromRef<T> for Twhere T: Clone,

source§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
source§

impl<T> FutureExt for T

source§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
source§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
source§

impl<T> Hashable for Twhere T: Hash,

§

type Output = u64

The type of the output value.
source§

fn hashed(&self) -> u64

A well-distributed integer derived from the data.
source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoRequest<T> for T

source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> PreferredContainer for Twhere T: Ord + Clone + 'static,

§

type Container = Vec<T>

The preferred container for the type.
source§

impl<T> ProgressEventTimestamp for Twhere T: Data + Debug + Any,

source§

fn as_any(&self) -> &(dyn Any + 'static)

Upcasts this ProgressEventTimestamp to Any. Read more
source§

fn type_name(&self) -> &'static str

Returns the name of the concrete type of this object. Read more
source§

impl<P, R> ProtoType<R> for Pwhere R: RustType<P>,

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> Visit for Twhere T: VisitChildren<T>,

source§

fn visit_post<F>(&self, f: &mut F) -> Result<(), RecursionLimitError>where F: FnMut(&T),

Post-order immutable infallible visitor for self.
source§

fn visit_post_nolimit<F>(&self, f: &mut F)where F: FnMut(&T),

👎Deprecated: Use visit_post instead.
Post-order immutable infallible visitor for self. Does not enforce a recursion limit.
source§

fn visit_mut_post<F>(&mut self, f: &mut F) -> Result<(), RecursionLimitError>where F: FnMut(&mut T),

Post-order mutable infallible visitor for self.
source§

fn visit_mut_post_nolimit<F>(&mut self, f: &mut F)where F: FnMut(&mut T),

👎Deprecated: Use visit_mut_post instead.
Post-order mutable infallible visitor for self. Does not enforce a recursion limit.
source§

fn try_visit_post<F, E>(&self, f: &mut F) -> Result<(), E>where F: FnMut(&T) -> Result<(), E>, E: From<RecursionLimitError>,

Post-order immutable fallible visitor for self.
source§

fn try_visit_mut_post<F, E>(&mut self, f: &mut F) -> Result<(), E>where F: FnMut(&mut T) -> Result<(), E>, E: From<RecursionLimitError>,

Post-order mutable fallible visitor for self.
source§

fn visit_pre<F>(&self, f: &mut F) -> Result<(), RecursionLimitError>where F: FnMut(&T),

Pre-order immutable infallible visitor for self.
source§

fn visit_pre_with_context<Context, AccFun, Visitor>( &self, init: Context, acc_fun: &mut AccFun, visitor: &mut Visitor ) -> Result<(), RecursionLimitError>where Context: Clone, AccFun: FnMut(Context, &T) -> Context, Visitor: FnMut(&Context, &T),

Pre-order immutable infallible visitor for self, which also accumulates context information along the path from the root to the current node’s parent. acc_fun is a similar closure as in fold. The accumulated context is passed to the visitor, along with the current node. Read more
source§

fn visit_pre_nolimit<F>(&self, f: &mut F)where F: FnMut(&T),

👎Deprecated: Use visit_pre instead.
Pre-order immutable infallible visitor for self. Does not enforce a recursion limit.
source§

fn visit_mut_pre<F>(&mut self, f: &mut F) -> Result<(), RecursionLimitError>where F: FnMut(&mut T),

Pre-order mutable infallible visitor for self.
source§

fn visit_mut_pre_nolimit<F>(&mut self, f: &mut F)where F: FnMut(&mut T),

👎Deprecated: Use visit_mut_pre instead.
Pre-order mutable infallible visitor for self. Does not enforce a recursion limit.
source§

fn try_visit_pre<F, E>(&self, f: &mut F) -> Result<(), E>where F: FnMut(&T) -> Result<(), E>, E: From<RecursionLimitError>,

Pre-order immutable fallible visitor for self.
source§

fn try_visit_mut_pre<F, E>(&mut self, f: &mut F) -> Result<(), E>where F: FnMut(&mut T) -> Result<(), E>, E: From<RecursionLimitError>,

Pre-order mutable fallible visitor for self.
source§

fn visit_pre_post<F1, F2>( &self, pre: &mut F1, post: &mut F2 ) -> Result<(), RecursionLimitError>where F1: FnMut(&T) -> Option<Vec<&T>>, F2: FnMut(&T),

source§

fn visit_pre_post_nolimit<F1, F2>(&self, pre: &mut F1, post: &mut F2)where F1: FnMut(&T) -> Option<Vec<&T>>, F2: FnMut(&T),

👎Deprecated: Use visit instead.
A generalization of Visit::visit_pre and Visit::visit_post. Does not enforce a recursion limit. Read more
source§

fn visit_mut_pre_post<F1, F2>( &mut self, pre: &mut F1, post: &mut F2 ) -> Result<(), RecursionLimitError>where F1: FnMut(&mut T) -> Option<Vec<&mut T>>, F2: FnMut(&mut T),

👎Deprecated: Use visit_mut instead.
source§

fn visit_mut_pre_post_nolimit<F1, F2>(&mut self, pre: &mut F1, post: &mut F2)where F1: FnMut(&mut T) -> Option<Vec<&mut T>>, F2: FnMut(&mut T),

👎Deprecated: Use visit_mut_pre_post instead.
A generalization of Visit::visit_mut_pre and Visit::visit_mut_post. Does not enforce a recursion limit. Read more
source§

fn visit<V>(&self, visitor: &mut V) -> Result<(), RecursionLimitError>where V: Visitor<T>,

source§

fn visit_mut<V>(&mut self, visitor: &mut V) -> Result<(), RecursionLimitError>where V: VisitorMut<T>,

source§

fn try_visit<V, E>(&self, visitor: &mut V) -> Result<(), E>where V: TryVisitor<T, E>, E: From<RecursionLimitError>,

source§

fn try_visit_mut<V, E>(&mut self, visitor: &mut V) -> Result<(), E>where V: TryVisitorMut<T, E>, E: From<RecursionLimitError>,

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> Data for Twhere T: Clone + 'static,

source§

impl<T> Data for Twhere T: Send + Sync + Any + Serialize + for<'a> Deserialize<'a> + 'static,

source§

impl<T> Data for Twhere T: Data + Ord + Debug,

source§

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,

source§

impl<T> ExchangeData for Twhere T: Data + Data,

source§

impl<T> ExchangeData for Twhere T: ExchangeData + Ord + Debug,