pub enum Mongo {}mongo only.Expand description
The backend a MongoDB comparison renders for.
UNINHABITED, because it is a name and never a value: it appears as
ComplexComparison<Mongo> and
ToDatabaseComparison<V, Mongo> and in no struct, since a MongoDB
comparison has no dialect to remember and so carries no marker field. The SQL rows name
sqlx::Sqlite and its siblings, which are sqlx’s own unit structs for sqlx’s own reasons; this
crate has no such reason, and an empty enum is the shape that says a value would have no meaning
rather than merely no use.
Trait Implementations§
Source§impl Backend for Mongo
The one row that is not a dialect, and the three answers it gives are each different from the
three above.
impl Backend for Mongo
The one row that is not a dialect, and the three answers it gives are each different from the three above.
§The builder is OWNED, and 'q goes unused
Every SQL row resolves the GAT to a borrow into the statement’s buffer, because a statement is a
larger thing a conjunct writes part of. A find filter is not part of anything — the document
IS the deliverable — and every value in it owns its bytes, so the accumulator owns the whole
filter and has nothing to borrow from the operands. 'q is therefore unmentioned on the right,
which is legal and is the measurement the seam was waiting for.
§The refusal is the ELEMENT SCOPE’s, and it arrived exactly as this row said it would
This said Infallible while every kind rendered a field’s own
operators: a comparison already holds storage values, chosen by the declaration and converted
once at the crossing, so nothing being rendered could be looked at and declined. BSON’s ceilings
are real — sixteen megabytes to a document, a hundred levels of nesting — and they are the
analogue of BindCeiling rather than something a scalar’s $in list
reaches: the SQL family deliberately puts no ceiling on single-column membership either, and
refuses only where a COMPOUND key multiplies a count the caller did not choose.
MongoLoweringError is what ended it, and the shape is the
SQL family’s own: $elemMatch holds a RESTRICTED sub-language, and what a nested comparison
writes into one is knowable only when it writes it. So the refusal belongs to the lowering for
the reason
SqlLoweringError::JsonElementScope does,
and this row names it rather than a second uninhabited type.
§The buffer is a String, where the SQL rows take an inline one
A rendered path here does not go into a statement’s text — it becomes a KEY, and
bson::Document’s keys are String. Any other buffer would be converted at the one place its
contents are used, so the inline storage the SQL rows gain would be spent again on the copy out
of it. The seam is what makes that statable rather than a compromise: the two families disagree
about the buffer for the same reason they disagree about . and _.
Source§type Builder<'q> = MongoConjunction
type Builder<'q> = MongoConjunction
Source§type Error = MongoLoweringError
type Error = MongoLoweringError
Source§fn buffer_with_capacity(capacity: usize) -> Self::Buffer
fn buffer_with_capacity(capacity: usize) -> Self::Buffer
capacity bytes before it grows. Read moreSource§fn write_column(at: At<'_>, out: &mut Self::Buffer)
fn write_column(at: At<'_>, out: &mut Self::Buffer)
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoBooleanComparison<V>
The same four operators the enum kind carries, lowered the same way — see
MongoScalarComparison for the two places the one-to-one
mapping is not the identity it looks like.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoBooleanComparison<V>
The same four operators the enum kind carries, lowered the same way — see
MongoScalarComparison for the two places the one-to-one
mapping is not the identity it looks like.
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoBytesComparison<V>
The eight operators map one-to-one onto $eq, $ne, $gt, $gte, $lt, $lte, $in and
$nin, and the walk is the scalar kind’s — see it for the two places that mapping is not the
identity it looks like, and for why the field path is rendered once.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoBytesComparison<V>
The eight operators map one-to-one onto $eq, $ne, $gt, $gte, $lt, $lte, $in and
$nin, and the walk is the scalar kind’s — see it for the two places that mapping is not the
identity it looks like, and for why the field path is rendered once.
§It asks nothing about which byte kind filled it, and that is the single-gate rule
An operator this backend cannot answer never reaches a comparison, because the crossing is the only way to set one and it refuses. A second check here would be a second place for the two to disagree — the same rule the SQL family’s bytes walk states, where there is no longer anything to check at all.
Source§impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoListComparison<V, C>
The six whole-collection operators map one-to-one onto $eq, $ne, $gt, $gte, $lt and
$lte, and the operand is the array itself — see this module’s note for the measurement that
says the last four are the element-wise order every other backend with an array type gives.
impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoListComparison<V, C>
The six whole-collection operators map one-to-one onto $eq, $ne, $gt, $gte, $lt and
$lte, and the operand is the array itself — see this module’s note for the measurement that
says the last four are the element-wise order every other backend with an array type gives.
The field path is rendered ONCE, for the reason
MongoScalarComparison’s walk gives: a BSON key is a string that
every operator of this comparison merges under.
Source§impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoSetComparison<V, C>
Three of the five whole-collection operators are one key each and two are BUILT — see
MongoSetComparison for the table and for what $type: "array" closes.
impl<V: MongoCarrier, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoSetComparison<V, C>
Three of the five whole-collection operators are one key each and two are BUILT — see
MongoSetComparison for the table and for what $type: "array" closes.
§This kind OVERFLOWS its own entry, and it is the second in the family to
eq and enclosed_by both write $type and $not, and eq and encloses both write $all,
so a comparison setting more than one of the three has keys no single operator document can
hold. The accumulator’s fold is the answer, exactly as it is for
MongoTextComparison’s twelve affix slots reaching two keys: the
first merges and the rest become $and branches. What that costs is one redundant branch where
two slots write the SAME guard — an $and of a true thing already said — and it is correct
rather than minimal.
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoDurationComparison<V>
Available on crate feature jiff only.The eight operators map one-to-one onto $eq, $ne, $gt, $gte, $lt, $lte, $in and
$nin, and the walk is the scalar kind’s — see it for the two places that mapping is not the
identity it looks like, and for why the field path is rendered once.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoDurationComparison<V>
jiff only.The eight operators map one-to-one onto $eq, $ne, $gt, $gte, $lt, $lte, $in and
$nin, and the walk is the scalar kind’s — see it for the two places that mapping is not the
identity it looks like, and for why the field path is rendered once.
§The order $gt answers in is the numeric one, and what that rests on is the TYPE
MongoDB’s comparison order puts Numbers (ints, longs, doubles, decimals) in ONE bracket, and
all numeric types are equivalent within it — so an Int64 operand is compared by value and the
four ordering operators mean what the filter means. The order itself carries no qualification,
where the byte kind’s does: BinData is compared by LENGTH before its bytes, so only a
fixed-width column’s $lt is the bytewise one and a variable-width column’s four ordering
operators are refused. This kind therefore needs no width and no gate.
What IS conditional is the bracket itself: MongoDB documents that a comparison operator only
performs comparisons on fields where the BSON type matches the query value’s type, with limited
cross-type comparison through type bracketing. So the operand and the stored field have to reach
BSON as the same arm — the agreement carrier’s module note is about, and the one it had to
measure for u32, where the serializer widens and From narrows.
For i64 the two routes agree: bson 3.1’s Serializer::serialize_i64 and impl From<i64> for Bson are both Bson::Int64, with no narrowing arm between them. carrier’s row writes that arm
directly, so a duration operand and the document field it is compared against are one BSON type.
Read from MongoDB’s documented comparison order rather than measured against a live server, which
is the standing the BinData rule already has here.
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoEnumComparison<V>
The four operators this kind carries are four of the scalar kind’s eight, and they lower the
same way — see MongoScalarComparison for the two places the
one-to-one mapping is not the identity it looks like.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoEnumComparison<V>
The four operators this kind carries are four of the scalar kind’s eight, and they lower the
same way — see MongoScalarComparison for the two places the
one-to-one mapping is not the identity it looks like.
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoFlagsComparison<V>
Available on crate feature flags only.The three mask words are NATIVE here, and that is the one place this kind’s two lowerings
genuinely differ.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoFlagsComparison<V>
flags only.The three mask words are NATIVE here, and that is the one place this kind’s two lowerings genuinely differ.
SQL has no bitwise PREDICATE, so its twin builds an arithmetic subject — (col & ?) = ? — and
carries a parenthesis to survive two dialects’ precedence. MongoDB’s query language carries the
predicates themselves, so hasAll/hasAny/hasNone are $bitsAllSet, $bitsAnySet and
$bitsAllClear written straight onto the field, with the mask as their operand.
The vacuous cases agree with the SQL’s and with bitflags’ own reading, which is what makes the
two lowerings one semantics rather than two that happen to look alike: over an empty mask
$bitsAllSet matches every document, $bitsAnySet matches none, and $bitsAllClear matches
every one — the same TRUE, FALSE, TRUE the SQL renders.
The four remaining words are four of the scalar kind’s eight and lower the same way.
Source§impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoNullable<C>
The inner comparison’s keys, then the null test’s — merged into the same field’s operator
document, which is what keeps the wrapper from opening a second key for a field that already has
one.
impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoNullable<C>
The inner comparison’s keys, then the null test’s — merged into the same field’s operator document, which is what keeps the wrapper from opening a second key for a field that already has one.
§The two keys are SHARED with the kinds, and the fold is what keeps them apart
$eq and $ne are the two most-written keys in this family: the scalar kind spells its own eq
and ne with them, and a collection kind writes $eq for has_element and for a
whole-collection equality. A comparison asking one of those AND the null test is one key twice,
and MongoConjunction::merge folds the second into a top-level $and rather than over the
first.
The fold is an INTERSECTION rather than a last-writer-wins, and the corpus separates the three
possible readings: a nullable list asking has_element: 1 with null: true renders
{v: {$eq: 1}, $and: [{v: {$eq: null}}]}, which returns ONE document — where keeping only the
first key returns two and keeping only the second returns four.
§The null test composes with non-emptiness rather than colliding with it
A collection’s any slot with no operator set renders {$elemMatch: {$exists: true}} — this
field is a non-empty array — and the null test renders beside it under its own key. $exists is
written INSIDE the element scope and never at the field, so the two documents have nothing to
fold. Measured, the pair a nullable list renders for null: false returns exactly the one
non-empty array whose members are all values.
§The whole address passes DOWN untouched
No frame is pushed, because this wrapper is the same field of the same document as its inner — the two conjuncts name one key and the merge is what renders it once.
Source§fn conjuncts(&self) -> usize
fn conjuncts(&self) -> usize
The whole SUBTREE’s count — C’s conjuncts plus this wrapper’s null test — because the
question a caller asks with it is whether anything at all will be rendered.
Source§impl<C: CollapsibleComparison<Mongo>> ComplexComparison<Mongo> for MongoRefComparison<C>
The forward reference: the collapsed predicate where the target constrains its id alone, one join
where it does not, and nothing at all where it asks nothing.
impl<C: CollapsibleComparison<Mongo>> ComplexComparison<Mongo> for MongoRefComparison<C>
The forward reference: the collapsed predicate where the target constrains its id alone, one join where it does not, and nothing at all where it asks nothing.
§The refusals are raised in the order the FACTS are about the relation
The WIDTH first, before anything is written and whichever branch follows: $lookup joins one
field to one field, so a target addressed by several is a broken relation rather than a broken
predicate, and the same relation must not answer one filter and refuse another.
The emptiness next, because a position nobody asked about writes nothing — which is what keeps a record carrying relation slots queryable for every field that is not one.
The DEPTH last, because it is a fact about the join this position is about to open and a position that opens none — the collapsed form, the empty one — has not reached any ceiling.
Source§impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoDerivedComparison<C>
The reverse position: one join per quantifier, each consuming its field before the next opens.
impl<C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoDerivedComparison<C>
The reverse position: one join per quantifier, each consuming its field before the next opens.
Source§impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoScalarComparison<V>
ONE impl, and the eight operators map ONE-TO-ONE onto $eq, $ne, $gt, $gte, $lt, $lte,
$in and $nin. That is a result rather than a coincidence: the operator vocabulary was chosen
against SQL and it turned out not to be SQL-shaped.
impl<V: MongoCarrier> ComplexComparison<Mongo> for MongoScalarComparison<V>
ONE impl, and the eight operators map ONE-TO-ONE onto $eq, $ne, $gt, $gte, $lt, $lte,
$in and $nin. That is a result rather than a coincidence: the operator vocabulary was chosen
against SQL and it turned out not to be SQL-shaped.
§Two ways the mapping is not the identity it looks like
ne is $ne and not a negated $eq. The SQL family renders every negation as
NOT ( … ), one spelling shared by a negated operator and its positive twin, because a dialect
writing its own NOT could put it inside a function call where three-valued logic makes it a
different question. MongoDB’s $ne is the operator, and {$not: {$eq: v}} is the same
question here, so the direct spelling is taken.
$ne matches a document whose field is NULL OR ABSENT, where SQL’s NOT (col = ?) on a
NULL column is UNKNOWN and matches nothing. That is not a defect in this row — it is MongoDB
matching where SQL’s three-valued logic declines to — and closing the difference is
MongoNullable’s question rather than the scalar kind’s. Recorded here
because the operator table is where it is invisible: a caller that wants those cells excluded
asks the column’s null test, and the wrapper writes {$ne: null} beside this key.
§The field path is rendered ONCE
A SQL leaf renders its column per conjunct, because each conjunct spells it. A BSON key is a string that every operator of this comparison is merged under, so the rendering happens once at the top of the body and the merge does the rest.
Source§impl<V: MongoCarrier + AsRef<str>> ComplexComparison<Mongo> for MongoTextComparison<V>
The eight value operators lower as the scalar kind’s do; the twelve affix slots are the whole of
what is new, and they arrive under exactly TWO keys.
impl<V: MongoCarrier + AsRef<str>> ComplexComparison<Mongo> for MongoTextComparison<V>
The eight value operators lower as the scalar kind’s do; the twelve affix slots are the whole of what is new, and they arrive under exactly TWO keys.
§A text comparison is the first kind that OVERFLOWS ITS OWN ENTRY
Every affix slot writes $regex or $not, so a comparison setting more than one of the six
positive forms has two $regexes for one field — which no document key can hold. The
accumulator’s answer is already built and it is MongoDB’s own: the first merges and the rest
become $and branches beside it. Nothing is dropped and nothing is refused.
That is worth stating because the scalar kind cannot reach it. Its eight operators are eight distinct keys, so its merge never overflows from one comparison and the fold looked like a safeguard against two comparisons at one path. Here it is the ordinary case: twenty slots reach at most ten keys, and the other ten fold.
§V: AsRef<str> is a REQUIREMENT here where SQLite’s lowering has none
The pattern is derived from the operand’s characters, so a carrier that binds an opaque encoding
has no characters to read — the same bound the two LIKE dialects carry, for the same reason.
SQLite escapes it with instr, which takes the operand as a VALUE; MongoDB has no such form,
because $regex is the only substring question it asks. So a stored text form with no
AsRef<str> is filterable with contains on exactly one of this crate’s four backends.
The omission is a bound naming the missing trait rather than a filter that matches something plausible:
use ingraph::{
At, ComplexComparison, FieldName, RecordAddress, TextFilter, TryFromFilter,
comparison::mongo::{MongoConjunction, MongoTextComparison},
};
// A text field stored as a blob — `MongoCarrier` through the crate's own `Vec<u8>` row, and no
// `AsRef<str>` for a pattern to be built from.
let c = MongoTextComparison::<Vec<u8>>::try_from_filter(
TextFilter::<String>::new().with_contains("cam".to_owned()),
)
.unwrap();
const ROW: RecordAddress = RecordAddress::new(FieldName::new("t"), &[FieldName::new("id")]);
let frame = At::new(&ROW).frame(FieldName::new("n"));
c.apply(frame.at(), MongoConjunction::new()).unwrap();Its twin, which must COMPILE — stable rustdoc runs a compile_fail block just far enough to see
it fail and never checks why, so the pair shares its call shape and one half has to be positive:
use bson::doc;
use ingraph::{
At, ComplexComparison, FieldName, RecordAddress, TextFilter, TryFromFilter,
comparison::mongo::{MongoConjunction, MongoTextComparison},
};
let c = MongoTextComparison::<String>::try_from_filter(
TextFilter::<String>::new().with_contains("cam".to_owned()),
)
.unwrap();
const ROW: RecordAddress = RecordAddress::new(FieldName::new("t"), &[FieldName::new("id")]);
let frame = At::new(&ROW).frame(FieldName::new("n"));
let filter = c
.apply(frame.at(), MongoConjunction::new())
.unwrap()
.into_document();
assert_eq!(filter, doc! { "n": { "$regex": bson::Regex {
pattern: "cam".try_into().unwrap(),
options: "".try_into().unwrap(),
} } });Source§impl ComplexComparison<Mongo> for MongoTimeRangeComparison
The lowering: the three words’ six possible operators at the two seats, then each end’s own
comparison beneath its own key.
impl ComplexComparison<Mongo> for MongoTimeRangeComparison
The lowering: the three words’ six possible operators at the two seats, then each end’s own comparison beneath its own key.
Source§fn apply<'q>(
&'q self,
at: At<'_>,
builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
Each seat’s key is rendered ONCE and every operator merged under it — the arrangement
MongoScalarComparison’s own body takes, and the reason a BSON leaf differs from a SQL one.
Source§impl<P, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoTimeRangedComparison<P, C>
The lowering: the stretch at the address it was given, then the payload one key below.
impl<P, C: ComplexComparison<Mongo>> ComplexComparison<Mongo> for MongoTimeRangedComparison<P, C>
The lowering: the stretch at the address it was given, then the payload one key below.
The stretch’s keys splice into the holder’s own document path because its entry in SEGMENTS
lends no name — the same flattening the SQL side spells with a shorter prefix, in this family’s
dotted spelling.
Source§impl<V: MongoCarrier, S: MongoSubjects> ComplexComparison<Mongo> for MongoKeyset<'_, V, S>
ONE impl, and the bounds are the operands’ and the subjects’: V: MongoCarrier is what a stored
value costs, exactly as it is for
MongoScalarComparison, and S: MongoSubjects
is what naming the left-hand sides costs.
impl<V: MongoCarrier, S: MongoSubjects> ComplexComparison<Mongo> for MongoKeyset<'_, V, S>
ONE impl, and the bounds are the operands’ and the subjects’: V: MongoCarrier is what a stored
value costs, exactly as it is for
MongoScalarComparison, and S: MongoSubjects
is what naming the left-hand sides costs.
It refuses nothing, so Backend::Error goes unnamed: what this
predicate could have refused was refused at MongoKeyset::resume, where no document had been
built.
Source§fn conjuncts(&self) -> usize
fn conjuncts(&self) -> usize
One, whatever the order holds: the expansion is a single $or document, and a cursor no
document can be after renders one $alwaysFalse, which is also one.
Source§fn apply<'q>(
&'q self,
at: At<'_>,
builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
§It goes through and, never through the merge
$or reads only at the top level of a filter document, so it has no field key to be merged
under — the same standing $expr and $nor have, and the same seam. What that buys is that a
page beside a filter is {…the filter's keys…, $and: [{$or: […]}]}, where every conjunct
keeps its own reading: the SQL family needs an outer bracket at exactly this position for the
same reason, and a document needs none because its structure is the bracketing.
Source§impl CompositeComparison<Mongo> for MongoTimeRangeComparison
The one place the fields a stretch spans are stated — the storage module’s own SEGMENTS, which
this family joins with . where the SQL one joins with _.
impl CompositeComparison<Mongo> for MongoTimeRangeComparison
The one place the fields a stretch spans are stated — the storage module’s own SEGMENTS, which
this family joins with . where the SQL one joins with _.
Source§const SEGMENTS: &'static [ColumnShape] = SEGMENTS
const SEGMENTS: &'static [ColumnShape] = SEGMENTS
Source§impl<P: ColumnKind, C: ComplexComparison<Mongo>> CompositeComparison<Mongo> for MongoTimeRangedComparison<P, C>
The width, from TimeRanged<P>’s own row — read rather than restated, which
is what the P parameter is for.
impl<P: ColumnKind, C: ComplexComparison<Mongo>> CompositeComparison<Mongo> for MongoTimeRangedComparison<P, C>
The width, from TimeRanged<P>’s own row — read rather than restated, which
is what the P parameter is for.
Source§const SEGMENTS: &'static [ColumnShape] = <TimeRanged<P> as ColumnKind>::SEGMENTS
const SEGMENTS: &'static [ColumnShape] = <TimeRanged<P> as ColumnKind>::SEGMENTS
Source§impl OrderCapability for Mongo
The row with NO KNOB, and the first one whose two answers disagree.
impl OrderCapability for Mongo
The row with NO KNOB, and the first one whose two answers disagree.
Nulls. MongoDB has one null position and it is already the framework’s: BSON’s total order
runs MinKey < Null < Numbers < String < …, with a MISSING field ordered exactly where a null
is, so nothing sorts below a missing value on an ascending term. There is no clause to state a
different one and none is wanted — the fixed position IS the pin, which is why this row is
Reachable without a
NullOrder answer behind it.
Repeats. A $sort is a DOCUMENT and its keys are unique, so a second term over one field
REPLACES the first: a page would sort by the last direction written and resume against the
first. That is the crate’s first genuinely unpushable order variant — an order SQLite, Postgres
and MySQL all render without complaint.
Collections. The frame’s first SEMANTICS disagreement, and the only row where a backend that
really does keep a collection in a column of the row still refuses to order by one. MongoDB’s
$sort over an array field does not compare arrays at all: it takes each document’s MINIMUM
element on an ascending term and its MAXIMUM on a descending one, so [9] sorts after [1, 99]
ascending and the two directions are not even reverses of one another. The framework’s rule is
element by element, so this is a different question under the client’s own term rather than a
missing feature — which is what
MongoSortError::Collection says when it
refuses one.
Source§const NULLS: NullPlacement = NullPlacement::Reachable
const NULLS: NullPlacement = NullPlacement::Reachable
Source§const REPEATED_TERMS: TermRepetition = TermRepetition::Unrepresentable
const REPEATED_TERMS: TermRepetition = TermRepetition::Unrepresentable
Source§const COLLECTIONS: CollectionOrdering = CollectionOrdering::Divergent
const COLLECTIONS: CollectionOrdering = CollectionOrdering::Divergent
Source§const COLLECTION_BOUNDARY: CollectionBoundary = CollectionBoundary::Unbindable
const COLLECTION_BOUNDARY: CollectionBoundary = CollectionBoundary::Unbindable
Source§const SHADOWS: ShadowOrdering = ShadowOrdering::Divergent
const SHADOWS: ShadowOrdering = ShadowOrdering::Divergent
sortable
collection’s companion column asks. Read moreSource§const SHADOW_BOUNDARY: ShadowBoundary = ShadowBoundary::Unbindable
const SHADOW_BOUNDARY: ShadowBoundary = ShadowBoundary::Unbindable
Source§impl<V> ReferentialComparison<Mongo> for MongoBytesComparison<V>
The bytes kind answers here for the reason it does in the SQL family — a BinData $eq is
bitwise, so the collapse’s assumption about two columns comparing alike is the one a byte column
cannot get wrong — and the refusal that costs a blob its ORDERING operators costs this nothing:
[MongoByteRefusal] is a question about $gt, and $gt is not a shape a foreign key may carry
under any backend.
impl<V> ReferentialComparison<Mongo> for MongoBytesComparison<V>
The bytes kind answers here for the reason it does in the SQL family — a BinData $eq is
bitwise, so the collapse’s assumption about two columns comparing alike is the one a byte column
cannot get wrong — and the refusal that costs a blob its ORDERING operators costs this nothing:
[MongoByteRefusal] is a question about $gt, and $gt is not a shape a foreign key may carry
under any backend.
Source§fn is_referential(&self) -> bool
fn is_referential(&self) -> bool
Source§impl<V> ReferentialComparison<Mongo> for MongoEnumComparison<V>
The enum kind answers, as its SQL twin does and over the same four operators.
impl<V> ReferentialComparison<Mongo> for MongoEnumComparison<V>
The enum kind answers, as its SQL twin does and over the same four operators.
Source§fn is_referential(&self) -> bool
fn is_referential(&self) -> bool
Source§impl<V> ReferentialComparison<Mongo> for MongoFlagsComparison<V>
Available on crate feature flags only.The flags kind answers as its SQL twin does, and narrows for the same reason: a mask word names
a SET of stored values, so no rewrite onto a parent’s foreign key exists for it.
impl<V> ReferentialComparison<Mongo> for MongoFlagsComparison<V>
flags only.The flags kind answers as its SQL twin does, and narrows for the same reason: a mask word names a SET of stored values, so no rewrite onto a parent’s foreign key exists for it.
Source§fn is_referential(&self) -> bool
fn is_referential(&self) -> bool
Source§impl<V> ReferentialComparison<Mongo> for MongoScalarComparison<V>
The scalar kind answers here for the reason it does in the SQL family: an $eq or an $in on
the target’s own key is a constraint the source’s reference field can carry instead.
impl<V> ReferentialComparison<Mongo> for MongoScalarComparison<V>
The scalar kind answers here for the reason it does in the SQL family: an $eq or an $in on
the target’s own key is a constraint the source’s reference field can carry instead.
Source§fn is_referential(&self) -> bool
fn is_referential(&self) -> bool
Source§impl<V> ReferentialComparison<Mongo> for MongoTextComparison<V>
The text kind answers for its two PLAIN operators alone — see the SQL twin’s note, whose reading
of what the collapse assumes about two columns is this one’s too.
impl<V> ReferentialComparison<Mongo> for MongoTextComparison<V>
The text kind answers for its two PLAIN operators alone — see the SQL twin’s note, whose reading of what the collapse assumes about two columns is this one’s too.
Source§fn is_referential(&self) -> bool
fn is_referential(&self) -> bool
Source§impl<F, V> ToDatabaseComparison<Option<V>, Mongo> for Nullable<F>where
F: ToDatabaseComparison<V, Mongo>,
The nullable filter crosses into the nullable comparison over whatever its inner kind crosses
into — one impl for every kind, present and future.
impl<F, V> ToDatabaseComparison<Option<V>, Mongo> for Nullable<F>where
F: ToDatabaseComparison<V, Mongo>,
The nullable filter crosses into the nullable comparison over whatever its inner kind crosses into — one impl for every kind, present and future.
The Option lands HERE and nowhere below it, for the reason
SqlNullable’s own row gives at length: the storage type
this impl is asked for is the COLUMN’s, so a nullable column names Option<V> and V is what
the inner comparison is built over. Without it, eq: Some(None) and null: Some(true) would be
two spellings of one question — and here the first of them is the wrong one twice over, since
{field: {$eq: null}} is this wrapper’s key rather than an operand’s.
It does not overlap the SQL family’s row for the same self type, for the coherence reason
MongoScalarComparison’s row records: that one is keyed on
Db: sqlx::Database, which is FOREIGN, and Mongo is local and has no such impl. This row
naming Mongo concretely is the whole of what keeps the two apart.
Source§type Comparison = MongoNullable<<F as ToDatabaseComparison<V, Mongo>>::Comparison>
type Comparison = MongoNullable<<F as ToDatabaseComparison<V, Mongo>>::Comparison>
V and lowering for Db.Source§impl<TF, P> ToDatabaseComparison<TimeRanged<P>, Mongo> for TimeRangedFilter<TF>
THE ROUTING ROW, and it reaches every payload whose filter routes on its own type — the SQL
twin’s shape and its argument, which is that a width is the domain type’s.
impl<TF, P> ToDatabaseComparison<TimeRanged<P>, Mongo> for TimeRangedFilter<TF>
THE ROUTING ROW, and it reaches every payload whose filter routes on its own type — the SQL twin’s shape and its argument, which is that a width is the domain type’s.
Source§type Comparison = MongoTimeRangedComparison<P, <TF as ToDatabaseComparison<P, Mongo>>::Comparison>
type Comparison = MongoTimeRangedComparison<P, <TF as ToDatabaseComparison<P, Mongo>>::Comparison>
V and lowering for Db.Source§impl ToDatabaseComparison<Timestamp, Mongo> for TimeRangeFilter
The range filter crosses into the range comparison for the one backend this family has, and the
header naming Mongo concretely is what keeps it from overlapping the SQL row — see
MongoScalarComparison’s own note, where the coherence argument is made.
impl ToDatabaseComparison<Timestamp, Mongo> for TimeRangeFilter
The range filter crosses into the range comparison for the one backend this family has, and the
header naming Mongo concretely is what keeps it from overlapping the SQL row — see
MongoScalarComparison’s own note, where the coherence argument is made.
Source§type Comparison = MongoTimeRangeComparison
type Comparison = MongoTimeRangeComparison
V and lowering for Db.Source§impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for BooleanFilter
One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for BooleanFilter
One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
Source§type Comparison = MongoBooleanComparison<V>
type Comparison = MongoBooleanComparison<V>
V and lowering for Db.Source§impl<D, V: MongoCarrier, I> ToDatabaseComparison<V, Mongo> for BytesFilter<D, I>
One backend, so one row — and the header naming Mongo concretely is what keeps it from
overlapping the SQL one, for the coherence reason
MongoScalarComparison’s row records.
impl<D, V: MongoCarrier, I> ToDatabaseComparison<V, Mongo> for BytesFilter<D, I>
One backend, so one row — and the header naming Mongo concretely is what keeps it from
overlapping the SQL one, for the coherence reason
MongoScalarComparison’s row records.
The bound is the LOWERING’s and it is exactly the carrier. Nothing here derives a value from an
operand the way a LIKE pattern or a $regex does, so a byte column asks for no
AsRef<[u8]> — the one bound MongoTextComparison’s row carries
that this does not, and the same place the SQL family’s three bytes impls land.
The WIDTH is not stated here. What decides a refusal is the crossing’s bound rather than the
lowering’s, and the crossing is deliberately not an item bound on this map — see
ToDatabaseComparison for why that promise cannot travel with the projection.
Source§type Comparison = MongoBytesComparison<V>
type Comparison = MongoBytesComparison<V>
V and lowering for Db.Source§impl<D, V: MongoCarrier, const N: usize, I> ToDatabaseComparison<V, Mongo> for FixedBytesFilter<D, N, I>
The fixed kind’s row, and it lands on the SAME comparison — a storage side reads no width.
impl<D, V: MongoCarrier, const N: usize, I> ToDatabaseComparison<V, Mongo> for FixedBytesFilter<D, N, I>
The fixed kind’s row, and it lands on the SAME comparison — a storage side reads no width.
Source§type Comparison = MongoBytesComparison<V>
type Comparison = MongoBytesComparison<V>
V and lowering for Db.Source§impl<D, VF, V> ToDatabaseComparison<V, Mongo> for ListFilter<D, VF>
The sequence filter crosses into the sequence comparison, and the ELEMENT filter crosses FIRST.
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for ListFilter<D, VF>
The sequence filter crosses into the sequence comparison, and the ELEMENT filter crosses FIRST.
VF is the member’s filter kind, and the comparison this collection holds is whatever THAT
filter crosses into over the SAME storage type — because a collection’s members are stored as
V, in the array beside its siblings. So this row projects through VF’s own crossing, which is
what keeps the member’s vocabulary the member’s.
The projection sits in the associated type and in the where-clause rather than in this header’s
ARGUMENTS, which is what keeps it resolvable: V and Mongo are both concrete here, so an
expansion assuming this predicate at a database it has not named yet has nothing to infer. The
SQL family reaches the same property by a different route — its projection lives inside a storage
row, because there the dialect is the thing not yet named.
It does not overlap the SQL family’s row for the same filter, for the coherence reason
MongoScalarComparison’s row records: that one is keyed on
Db: CollectionStorage<V, VF>, whose supertrait is the FOREIGN sqlx::Database, and Mongo
is local and has no such row.
Source§type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
V and lowering for Db.Source§impl<D, VF, V> ToDatabaseComparison<V, Mongo> for SetFilter<D, VF>
The same map for a set.
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for SetFilter<D, VF>
The same map for a set.
Source§type Comparison = MongoSetComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
type Comparison = MongoSetComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
V and lowering for Db.Source§impl<D, VF, V> ToDatabaseComparison<V, Mongo> for QuantifiedFilter<D, VF>
The NARROW collection reads the SEQUENCE comparison, for the reason its SQL twin reads the
sequence strategy: a quantified column’s members are written in the order the writer produced
them and the filter simply declines to ask about that order. There is one BSON array either way,
so what the choice decides here is only which struct holds the two crossed slots.
impl<D, VF, V> ToDatabaseComparison<V, Mongo> for QuantifiedFilter<D, VF>
The NARROW collection reads the SEQUENCE comparison, for the reason its SQL twin reads the sequence strategy: a quantified column’s members are written in the order the writer produced them and the filter simply declines to ask about that order. There is one BSON array either way, so what the choice decides here is only which struct holds the two crossed slots.
Source§type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>
V and lowering for Db.Source§impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for DurationFilter
Available on crate feature jiff only.One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for DurationFilter
jiff only.One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
V is open here and the CROSSING below is not, which is the split
ToDatabaseComparison’s own note describes: a storage form is a declaration rather than a law,
so a column that declares its own converter reaches any carrier this backend has, while a column
that declares none reaches the one this crate answers with.
Source§type Comparison = MongoDurationComparison<V>
type Comparison = MongoDurationComparison<V>
V and lowering for Db.Source§impl<D, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for EnumFilter<D>
One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
impl<D, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for EnumFilter<D>
One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
Source§type Comparison = MongoEnumComparison<V>
type Comparison = MongoEnumComparison<V>
V and lowering for Db.Source§impl<D, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for FlagsFilter<D>
Available on crate feature flags only.One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
impl<D, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for FlagsFilter<D>
flags only.One backend, so one row — and the header is concrete for the coherence reason
MongoScalarComparison’s records.
Source§type Comparison = MongoFlagsComparison<V>
type Comparison = MongoFlagsComparison<V>
V and lowering for Db.Source§impl<D, I, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for ScalarFilter<D, I>
The scalar filter crosses into the scalar comparison for the one backend this family has, and
the header naming Mongo concretely is what keeps it from overlapping the SQL row.
impl<D, I, V: MongoCarrier> ToDatabaseComparison<V, Mongo> for ScalarFilter<D, I>
The scalar filter crosses into the scalar comparison for the one backend this family has, and
the header naming Mongo concretely is what keeps it from overlapping the SQL row.
Coherence permits it because Mongo is LOCAL and sqlx::Database is foreign: only this crate
could write impl sqlx::Database for Mongo, and it has not, so Db = Mongo cannot unify with a
header demanding one. Measured rather than assumed — the SQL row’s own note predicted this and
this is the compilation that checks it.
Source§type Comparison = MongoScalarComparison<V>
type Comparison = MongoScalarComparison<V>
V and lowering for Db.Source§impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for ConfidenceFilter
The CONFIDENCE kind’s two rows, and they are the SQL family’s word for word with the dialect
parameter gone — see
SqlScalarComparison’s pair, where the whole
argument is: a widthless operand gets its width from the COLUMN’s storage type, and V: ScoreKind
is the row that supplies it.
impl<V: MongoCarrier> ToDatabaseComparison<V, Mongo> for ConfidenceFilter
The CONFIDENCE kind’s two rows, and they are the SQL family’s word for word with the dialect
parameter gone — see
SqlScalarComparison’s pair, where the whole
argument is: a widthless operand gets its width from the COLUMN’s storage type, and V: ScoreKind
is the row that supplies it.
Source§type Comparison = MongoScalarComparison<V>
type Comparison = MongoScalarComparison<V>
V and lowering for Db.Source§impl<D, I, V: MongoCarrier + AsRef<str>> ToDatabaseComparison<V, Mongo> for TextFilter<D, I>
The crossing states the LOWERING’s bounds rather than the carrier’s alone, so a storage type
whose text this backend cannot read is refused where it is DECLARED.
impl<D, I, V: MongoCarrier + AsRef<str>> ToDatabaseComparison<V, Mongo> for TextFilter<D, I>
The crossing states the LOWERING’s bounds rather than the carrier’s alone, so a storage type whose text this backend cannot read is refused where it is DECLARED.
Its SQL twin cannot do that. Three concrete impls whose bounds disagree have no bound list to
restate, so the SQL row names SqlTextComparison<V, Db>: ComplexComparison<Db> instead. This
family has one lowering, so its two bounds are the honest statement and the error a declarer
gets names the missing trait.
The READING parameter is carried but never read: what a crossing spends is the OPERANDS, and the
wire form they arrived under is spent by the time one is built. Generic over it so a declarer’s
own text type — whose filter names a marker that crate owns — reaches storage exactly as
TextFilter<String> does.
Source§type Comparison = MongoTextComparison<V>
type Comparison = MongoTextComparison<V>
V and lowering for Db.Source§impl<F, C: ComplexComparison<Mongo>> ToLoweredRelatedComparison<C, Mongo> for RelatedFilter<F>
The reverse position’s LOWERING, one dialect over — reached through the quantifier vocabulary, so
a record’s emitted lowering names no projection at a generic dialect.
impl<F, C: ComplexComparison<Mongo>> ToLoweredRelatedComparison<C, Mongo> for RelatedFilter<F>
The reverse position’s LOWERING, one dialect over — reached through the quantifier vocabulary, so a record’s emitted lowering names no projection at a generic dialect.
Source§fn conjuncts(comparison: &Self::Comparison) -> usize
fn conjuncts(comparison: &Self::Comparison) -> usize
comparison renders — ComplexComparison::conjuncts’s answer, reached
without naming the type that gives it.Source§fn apply<'q>(
comparison: &'q Self::Comparison,
at: At<'_>,
builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
fn apply<'q>( comparison: &'q Self::Comparison, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
comparison’s conjuncts for at into builder, and give the builder back —
ComplexComparison::apply, reached the same way. Read moreSource§impl<F, R, C: CollapsibleComparison<Mongo>> ToLoweredRelatedComparison<C, Mongo> for RefFilter<F, R>
The forward position’s, its twin — the far side must COLLAPSE here, because the semi-join asks it
whether the reference’s own field answers the whole question.
impl<F, R, C: CollapsibleComparison<Mongo>> ToLoweredRelatedComparison<C, Mongo> for RefFilter<F, R>
The forward position’s, its twin — the far side must COLLAPSE here, because the semi-join asks it whether the reference’s own field answers the whole question.
Source§fn conjuncts(comparison: &Self::Comparison) -> usize
fn conjuncts(comparison: &Self::Comparison) -> usize
comparison renders — ComplexComparison::conjuncts’s answer, reached
without naming the type that gives it.Source§fn apply<'q>(
comparison: &'q Self::Comparison,
at: At<'_>,
builder: <Mongo as Backend>::Builder<'q>,
) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
fn apply<'q>( comparison: &'q Self::Comparison, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>
comparison’s conjuncts for at into builder, and give the builder back —
ComplexComparison::apply, reached the same way. Read moreSource§impl<F, C> ToRelatedComparison<C, Mongo> for RelatedFilter<F>
MongoDB’s answer to the reverse position’s crossing map — the SQL family’s row one dialect
over, and the two are told apart by that row’s Db: sqlx::Database head bound.
impl<F, C> ToRelatedComparison<C, Mongo> for RelatedFilter<F>
MongoDB’s answer to the reverse position’s crossing map — the SQL family’s row one dialect
over, and the two are told apart by that row’s Db: sqlx::Database head bound.
It asks NOTHING of C, as the SQL row does not: the map carries no item bound, so a row has no
promise to prove and this kind’s own lowering clause stays on the ComplexComparison impl below
and on the ToLoweredRelatedComparison row
beside this one. See ToRelatedComparison for the cycle a restated
bound closed on the ordinary mutual pair.
Source§type Comparison = MongoDerivedComparison<C>
type Comparison = MongoDerivedComparison<C>
C over the far side’s rows. Read moreSource§impl<F, R, C> ToRelatedComparison<C, Mongo> for RefFilter<F, R>
The FORWARD half of the same answer — a ref column’s widened filter, one dialect over.
impl<F, R, C> ToRelatedComparison<C, Mongo> for RefFilter<F, R>
The FORWARD half of the same answer — a ref column’s widened filter, one dialect over.
Optional for the SQL row’s reason: nothing was asked has no value to be, since this kind holds
the far side’s comparison bare and an emitted comparison has no Default.
Source§type Comparison = Option<MongoRefComparison<C>>
type Comparison = Option<MongoRefComparison<C>>
C over the far side’s rows. Read moreAuto Trait Implementations§
impl Freeze for Mongo
impl RefUnwindSafe for Mongo
impl Send for Mongo
impl Sync for Mongo
impl Unpin for Mongo
impl UnsafeUnpin for Mongo
impl UnwindSafe for Mongo
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<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§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.Source§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.Source§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.Source§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.Source§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.Source§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.Source§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.Source§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.impl<T> Fruit for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§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> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§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 moreSource§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 moreSource§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
Source§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
Source§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.Source§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.Source§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.Source§impl<T> Pointable for T
impl<T> Pointable for T
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<T> Tap for T
impl<T> Tap for T
Source§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 moreSource§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 moreSource§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 moreSource§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 moreSource§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 moreSource§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 moreSource§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.Source§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.Source§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.Source§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.Source§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.Source§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.Source§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.