Enum Expr
pub enum Expr {
Show 64 variants
Identifier(Ident),
CompoundIdentifier(Vec<Ident>),
CompoundFieldAccess {
root: Box<Expr>,
access_chain: Vec<AccessExpr>,
},
JsonAccess {
value: Box<Expr>,
path: JsonPath,
},
CompositeAccess {
expr: Box<Expr>,
key: Ident,
},
IsFalse(Box<Expr>),
IsNotFalse(Box<Expr>),
IsTrue(Box<Expr>),
IsNotTrue(Box<Expr>),
IsNull(Box<Expr>),
IsNotNull(Box<Expr>),
IsUnknown(Box<Expr>),
IsNotUnknown(Box<Expr>),
IsDistinctFrom(Box<Expr>, Box<Expr>),
IsNotDistinctFrom(Box<Expr>, Box<Expr>),
IsNormalized {
expr: Box<Expr>,
form: Option<NormalizationForm>,
negated: bool,
},
InList {
expr: Box<Expr>,
list: Vec<Expr>,
negated: bool,
},
InSubquery {
expr: Box<Expr>,
subquery: Box<Query>,
negated: bool,
},
InUnnest {
expr: Box<Expr>,
array_expr: Box<Expr>,
negated: bool,
},
Between {
expr: Box<Expr>,
negated: bool,
low: Box<Expr>,
high: Box<Expr>,
},
BinaryOp {
left: Box<Expr>,
op: BinaryOperator,
right: Box<Expr>,
},
Like {
negated: bool,
any: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<String>,
},
ILike {
negated: bool,
any: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<String>,
},
SimilarTo {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<String>,
},
RLike {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
regexp: bool,
},
AnyOp {
left: Box<Expr>,
compare_op: BinaryOperator,
right: Box<Expr>,
is_some: bool,
},
AllOp {
left: Box<Expr>,
compare_op: BinaryOperator,
right: Box<Expr>,
},
UnaryOp {
op: UnaryOperator,
expr: Box<Expr>,
},
Convert {
is_try: bool,
expr: Box<Expr>,
data_type: Option<DataType>,
charset: Option<ObjectName>,
target_before_value: bool,
styles: Vec<Expr>,
},
Cast {
kind: CastKind,
expr: Box<Expr>,
data_type: DataType,
format: Option<CastFormat>,
},
AtTimeZone {
timestamp: Box<Expr>,
time_zone: Box<Expr>,
},
Extract {
field: DateTimeField,
syntax: ExtractSyntax,
expr: Box<Expr>,
},
Ceil {
expr: Box<Expr>,
field: CeilFloorKind,
},
Floor {
expr: Box<Expr>,
field: CeilFloorKind,
},
Position {
expr: Box<Expr>,
in: Box<Expr>,
},
Substring {
expr: Box<Expr>,
substring_from: Option<Box<Expr>>,
substring_for: Option<Box<Expr>>,
special: bool,
},
Trim {
expr: Box<Expr>,
trim_where: Option<TrimWhereField>,
trim_what: Option<Box<Expr>>,
trim_characters: Option<Vec<Expr>>,
},
Overlay {
expr: Box<Expr>,
overlay_what: Box<Expr>,
overlay_from: Box<Expr>,
overlay_for: Option<Box<Expr>>,
},
Collate {
expr: Box<Expr>,
collation: ObjectName,
},
Nested(Box<Expr>),
Value(Value),
IntroducedString {
introducer: String,
value: Value,
},
TypedString {
data_type: DataType,
value: String,
},
Function(Function),
Method(Method),
Case {
operand: Option<Box<Expr>>,
conditions: Vec<Expr>,
results: Vec<Expr>,
else_result: Option<Box<Expr>>,
},
Exists {
subquery: Box<Query>,
negated: bool,
},
Subquery(Box<Query>),
GroupingSets(Vec<Vec<Expr>>),
Cube(Vec<Vec<Expr>>),
Rollup(Vec<Vec<Expr>>),
Tuple(Vec<Expr>),
Struct {
values: Vec<Expr>,
fields: Vec<StructField>,
},
Named {
expr: Box<Expr>,
name: Ident,
},
Dictionary(Vec<DictionaryField>),
Map(Map),
Array(Array),
Interval(Interval),
MatchAgainst {
columns: Vec<Ident>,
match_value: Value,
opt_search_modifier: Option<SearchModifier>,
},
Wildcard(AttachedToken),
QualifiedWildcard(ObjectName, AttachedToken),
OuterJoin(Box<Expr>),
Prior(Box<Expr>),
Lambda(LambdaFunction),
}
Expand description
An SQL expression of any type.
§Semantics / Type Checking
The parser does not distinguish between expressions of different types
(e.g. boolean vs string). The caller is responsible for detecting and
validating types as necessary (for example WHERE 1
vs SELECT 1=1
)
See the README.md for more details.
§Equality and Hashing Does not Include Source Locations
The Expr
type implements PartialEq
and Eq
based on the semantic value
of the expression (not bitwise comparison). This means that Expr
instances
that are semantically equivalent but have different spans (locations in the
source tree) will compare as equal.
Variants§
Identifier(Ident)
Identifier e.g. table name or column name
CompoundIdentifier(Vec<Ident>)
Multi-part identifier, e.g. table_alias.column
or schema.table.col
CompoundFieldAccess
Multi-part expression access.
This structure represents an access chain in structured / nested types such as maps, arrays, and lists:
- Array
- A 1-dim array
a[1]
will be represented like:CompoundFieldAccess(Ident('a'), vec![Subscript(1)]
- A 2-dim array
a[1][2]
will be represented like:CompoundFieldAccess(Ident('a'), vec![Subscript(1), Subscript(2)]
- A 1-dim array
- Map or Struct (Bracket-style)
- A map
a['field1']
will be represented like:CompoundFieldAccess(Ident('a'), vec![Subscript('field')]
- A 2-dim map
a['field1']['field2']
will be represented like:CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Subscript('field2')]
- A map
- Struct (Dot-style) (only effect when the chain contains both subscript and expr)
- A struct access
a[field1].field2
will be represented like:CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Ident('field2')]
- A struct access
- If a struct access likes
a.field1.field2
, it will be represented by CompoundIdentifier([a, field1, field2])
JsonAccess
Access data nested in a value containing semi-structured data, such as
the VARIANT
type on Snowflake. for example src:customer[0].name
.
See https://docs.snowflake.com/en/user-guide/querying-semistructured. See https://docs.databricks.com/en/sql/language-manual/functions/colonsign.html.
CompositeAccess
CompositeAccess eg: SELECT foo(bar).z, (information_schema._pg_expandarray(array[‘i’,‘i’])).n
IsFalse(Box<Expr>)
IS FALSE
operator
IsNotFalse(Box<Expr>)
IS NOT FALSE
operator
IsTrue(Box<Expr>)
IS TRUE
operator
IsNotTrue(Box<Expr>)
IS NOT TRUE
operator
IsNull(Box<Expr>)
IS NULL
operator
IsNotNull(Box<Expr>)
IS NOT NULL
operator
IsUnknown(Box<Expr>)
IS UNKNOWN
operator
IsNotUnknown(Box<Expr>)
IS NOT UNKNOWN
operator
IsDistinctFrom(Box<Expr>, Box<Expr>)
IS DISTINCT FROM
operator
IsNotDistinctFrom(Box<Expr>, Box<Expr>)
IS NOT DISTINCT FROM
operator
IsNormalized
<expr> IS [ NOT ] [ form ] NORMALIZED
InList
[ NOT ] IN (val1, val2, ...)
InSubquery
[ NOT ] IN (SELECT ...)
InUnnest
[ NOT ] IN UNNEST(array_expression)
Between
<expr> [ NOT ] BETWEEN <low> AND <high>
BinaryOp
Binary operation e.g. 1 + 1
or foo > bar
Like
[NOT] LIKE <pattern> [ESCAPE <escape_character>]
ILike
ILIKE
(case-insensitive LIKE
)
SimilarTo
SIMILAR TO regex
RLike
MySQL: RLIKE regex or REGEXP regex
AnyOp
ANY
operation e.g. foo > ANY(bar)
, comparison operator is one of [=, >, <, =>, =<, !=]
https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any
AllOp
ALL
operation e.g. foo > ALL(bar)
, comparison operator is one of [=, >, <, =>, =<, !=]
https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any
UnaryOp
Unary operation e.g. NOT foo
Convert
CONVERT a value to a different data type or character encoding. e.g. CONVERT(foo USING utf8mb4)
Fields
is_try: bool
CONVERT (false) or TRY_CONVERT (true) https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16
charset: Option<ObjectName>
The target character encoding
Cast
CAST
an expression to a different data type e.g. CAST(foo AS VARCHAR(123))
AtTimeZone
AT a timestamp to a different timezone e.g. FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'
Extract
Extract a field from a timestamp e.g. EXTRACT(MONTH FROM foo)
Or EXTRACT(MONTH, foo)
Syntax:
EXTRACT(DateTimeField FROM <expr>) | EXTRACT(DateTimeField, <expr>)
Ceil
CEIL(<expr> [TO DateTimeField])
CEIL( <input_expr> [, <scale_expr> ] )
Floor
FLOOR(<expr> [TO DateTimeField])
FLOOR( <input_expr> [, <scale_expr> ] )
Position
POSITION(<expr> in <expr>)
Substring
SUBSTRING(<expr> [FROM <expr>] [FOR <expr>])
or
SUBSTRING(<expr>, <expr>, <expr>)
Fields
Trim
TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)
TRIM(<expr>)
TRIM(<expr>, [, characters]) -- only Snowflake or Bigquery
Fields
Overlay
OVERLAY(<expr> PLACING <expr> FROM <expr>[ FOR <expr> ]
Fields
Collate
expr COLLATE collation
Nested(Box<Expr>)
Nested expression e.g. (foo > bar)
or (1)
Value(Value)
A literal value, such as string, number, date or NULL
IntroducedString
TypedString
A constant of form <data_type> 'value'
.
This can represent ANSI SQL DATE
, TIME
, and TIMESTAMP
literals (such as DATE '2020-01-01'
),
as well as constants of other types (a non-standard PostgreSQL extension).
Function(Function)
Scalar function call e.g. LEFT(foo, 5)
Method(Method)
Arbitrary expr method call
Syntax:
<arbitrary-expr>.<function-call>.<function-call-expr>...
arbitrary-expr
can be any expression including a function call.
Example:
SELECT (SELECT ',' + name FROM sys.objects FOR XML PATH(''), TYPE).value('.','NVARCHAR(MAX)')
SELECT CONVERT(XML,'<Book>abc</Book>').value('.','NVARCHAR(MAX)').value('.','NVARCHAR(MAX)')
(mssql): https://learn.microsoft.com/en-us/sql/t-sql/xml/xml-data-type-methods?view=sql-server-ver16
Case
CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END
Note we only recognize a complete single expression as <condition>
,
not < 0
nor 1, 2, 3
as allowed in a <simple when clause>
per
https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause
Fields
Exists
An exists expression [ NOT ] EXISTS(SELECT ...)
, used in expressions like
WHERE [ NOT ] EXISTS (SELECT ...)
.
Subquery(Box<Query>)
A parenthesized subquery (SELECT ...)
, used in expression like
SELECT (subquery) AS x
or WHERE (subquery) = x
GroupingSets(Vec<Vec<Expr>>)
The GROUPING SETS
expr.
Cube(Vec<Vec<Expr>>)
The CUBE
expr.
Rollup(Vec<Vec<Expr>>)
The ROLLUP
expr.
Tuple(Vec<Expr>)
ROW / TUPLE a single value, such as SELECT (1, 2)
Struct
Struct
literal expression
Syntax:
STRUCT<[field_name] field_type, ...>( expr1 [, ... ])
[BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type)
[Databricks](https://docs.databricks.com/en/sql/language-manual/functions/struct.html)
Named
Dictionary(Vec<DictionaryField>)
Map(Map)
Array(Array)
An array expression e.g. ARRAY[1, 2]
Interval(Interval)
An interval expression e.g. INTERVAL '1' YEAR
MatchAgainst
MySQL
specific text search function (1).
Syntax:
MATCH (<col>, <col>, ...) AGAINST (<expr> [<search modifier>])
<col> = CompoundIdentifier
<expr> = String literal
Fields
Wildcard(AttachedToken)
QualifiedWildcard(ObjectName, AttachedToken)
Qualified wildcard, e.g. alias.*
or schema.table.*
.
(Same caveats apply to QualifiedWildcard
as to Wildcard
.)
OuterJoin(Box<Expr>)
Some dialects support an older syntax for outer joins where columns are
marked with the (+)
operator in the WHERE clause, for example:
SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)
which is equivalent to
SELECT t1.c1, t2.c2 FROM t1 LEFT OUTER JOIN t2 ON t1.c1 = t2.c2
See https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause.
Prior(Box<Expr>)
A reference to the prior level in a CONNECT BY clause.
Lambda(LambdaFunction)
A lambda function.
Syntax:
param -> expr | (param1, ...) -> expr
See https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html.
Trait Implementations§
§impl<'de> Deserialize<'de> for Expr
impl<'de> Deserialize<'de> for Expr
§fn deserialize<__D>(
__deserializer: __D,
) -> Result<Expr, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D,
) -> Result<Expr, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
§impl From<Expr> for FunctionArgExpr
impl From<Expr> for FunctionArgExpr
§fn from(wildcard_expr: Expr) -> FunctionArgExpr
fn from(wildcard_expr: Expr) -> FunctionArgExpr
§impl Ord for Expr
impl Ord for Expr
§impl PartialOrd for Expr
impl PartialOrd for Expr
§impl Serialize for Expr
impl Serialize for Expr
§fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
§impl Spanned for Expr
§partial span
Most expressions are missing keywords in their spans.
f.e. IS NULL <expr>
reports as <expr>::span
.
impl Spanned for Expr
§partial span
Most expressions are missing keywords in their spans.
f.e. IS NULL <expr>
reports as <expr>::span
.
Missing spans:
- Expr::TypedString
- Expr::MatchAgainst # MySQL specific
- Expr::RLike # MySQL specific
- Expr::Struct # BigQuery specific
- Expr::Named # BigQuery specific
- Expr::Dictionary # DuckDB specific
- Expr::Map # DuckDB specific
- Expr::Lambda
§impl VisitMut for Expr
impl VisitMut for Expr
fn visit<V>(&mut self, visitor: &mut V) -> ControlFlow<<V as VisitorMut>::Break>where
V: VisitorMut,
impl Eq for Expr
impl StructuralPartialEq for Expr
Auto Trait Implementations§
impl Freeze for Expr
impl RefUnwindSafe for Expr
impl Send for Expr
impl Sync for Expr
impl Unpin for Expr
impl UnwindSafe for Expr
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> CallHasher for T
impl<T> CallHasher for T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<T> Conv for T
impl<T> Conv for T
§impl<T, V> Convert<T> for Vwhere
V: Into<T>,
impl<T, V> Convert<T> for Vwhere
V: Into<T>,
fn convert(value: Self) -> T
fn convert_box(value: Box<Self>) -> Box<T>
fn convert_vec(value: Vec<Self>) -> Vec<T>
fn convert_vec_box(value: Vec<Box<Self>>) -> Vec<Box<T>>
fn convert_matrix(value: Vec<Vec<Self>>) -> Vec<Vec<T>>
fn convert_option(value: Option<Self>) -> Option<T>
fn convert_option_box(value: Option<Box<Self>>) -> Option<Box<T>>
fn convert_option_vec(value: Option<Vec<Self>>) -> Option<Vec<T>>
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request
Source§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.