Skip to main content

Mongo

Enum Mongo 

Source
pub enum Mongo {}
Available on crate feature 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.

§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

The builder a comparison for this backend is handed, renders into, and hands back. Read more
Source§

type Error = MongoLoweringError

What a lowering for this backend refuses with. Read more
Source§

type Buffer = String

The text buffer this backend renders a column name into. Read more
Source§

fn buffer_with_capacity(capacity: usize) -> Self::Buffer

A buffer able to take capacity bytes before it grows. Read more
Source§

fn write_column(at: At<'_>, out: &mut Self::Buffer)

Write the column at names into out, joined and bracketed as this backend spells one. Read more
Source§

fn buffer() -> Self::Buffer

A buffer at this backend’s own default capacity. Read more
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.

Source§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

Source§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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

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§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

Source§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

§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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

Source§

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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

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§

fn conjuncts(&self) -> usize

How many conjuncts apply emits — its own and its children’s. Read more
Source§

fn apply<'q>( &'q self, at: At<'_>, builder: <Mongo as Backend>::Builder<'q>, ) -> Result<<Mongo as Backend>::Builder<'q>, <Mongo as Backend>::Error>

Render this comparison’s conjuncts for at into builder, and give the builder back. Read more
Source§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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.

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

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>

§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§

fn is_empty(&self) -> bool

True when no operator is set anywhere in this comparison, so lowering would emit nothing.
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 _.

Source§

const SEGMENTS: &'static [ColumnShape] = SEGMENTS

The segments it pushes, each carrying whatever IT spans.
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.

Source§

const SEGMENTS: &'static [ColumnShape] = <TimeRanged<P> as ColumnKind>::SEGMENTS

The segments it pushes, each carrying whatever IT spans.
Source§

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

Where this backend can put a missing value in an ordering.
Source§

const REPEATED_TERMS: TermRepetition = TermRepetition::Unrepresentable

Whether this backend’s ordering can carry two terms over one subject.
Source§

const COLLECTIONS: CollectionOrdering = CollectionOrdering::Divergent

What this backend’s ordering over a COLLECTION column means, against the framework’s one meaning. Read more
Source§

const COLLECTION_BOUNDARY: CollectionBoundary = CollectionBoundary::Unbindable

Whether this backend can BIND a whole collection as one boundary value. Read more
Source§

const SHADOWS: ShadowOrdering = ShadowOrdering::Divergent

What this backend’s ordering over a BINARY column means — the question a sortable collection’s companion column asks. Read more
Source§

const SHADOW_BOUNDARY: ShadowBoundary = ShadowBoundary::Unbindable

Whether this backend can BIND a companion column’s bytes as one boundary value. Read more
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.

Source§

fn is_referential(&self) -> bool

True when the ONLY operator this comparison sets is a plain equality or a plain membership. Read more
Source§

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

True when the ONLY operator this comparison sets is a plain equality or a plain membership. Read more
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.

Source§

fn is_referential(&self) -> bool

True when the ONLY operator this comparison sets is a plain equality or a plain membership. Read more
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.

Source§

fn is_referential(&self) -> bool

True when the ONLY operator this comparison sets is a plain equality or a plain membership. Read more
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.

Source§

fn is_referential(&self) -> bool

True when the ONLY operator this comparison sets is a plain equality or a plain membership. Read more
Source§

impl<F, V> ToDatabaseComparison<Option<V>, Mongo> for Nullable<F>

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoTimeRangedComparison<P, <TF as ToDatabaseComparison<P, Mongo>>::Comparison>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoTimeRangeComparison

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoBooleanComparison<V>

The comparison a filter of this kind crosses into, holding 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.

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoBytesComparison<V>

The comparison a filter of this kind crosses into, holding 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.

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>

The comparison a filter of this kind crosses into, holding V and lowering for Db.
Source§

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoListComparison<V, <VF as ToDatabaseComparison<V, Mongo>>::Comparison>

The comparison a filter of this kind crosses into, holding 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.

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoEnumComparison<V>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoFlagsComparison<V>

The comparison a filter of this kind crosses into, holding 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.

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

type Comparison = MongoScalarComparison<V>

The comparison a filter of this kind crosses into, holding 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.

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>

The comparison a filter of this kind crosses into, holding 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.

Source§

fn conjuncts(comparison: &Self::Comparison) -> usize

How many conjuncts 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>

Render comparison’s conjuncts for at into builder, and give the builder back — ComplexComparison::apply, reached the same way. Read more
Source§

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

How many conjuncts 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>

Render comparison’s conjuncts for at into builder, and give the builder back — ComplexComparison::apply, reached the same way. Read more
Source§

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>

The comparison this position crosses into, quantifying C over the far side’s rows. Read more
Source§

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>>

The comparison this position crosses into, quantifying C over the far side’s rows. Read more

Auto 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> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts 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>

Converts 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)

Converts &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)

Converts &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
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Send + Sync>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Fruit for T
where T: Send + Downcast,

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 T
where 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> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts 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 more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts 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 more
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows 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
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows 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
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

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> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> State<Identity> for T

Source§

type Output = T

The type Self projects to.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .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
where Self: BorrowMut<B>, B: ?Sized,

Calls .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
where Self: AsRef<R>, R: ?Sized,

Calls .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
where Self: AsMut<R>, R: ?Sized,

Calls .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
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

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

Source§

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 T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

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