pub struct Language(/* private fields */);derive only.Expand description
A primary language subtag, in the shortest spelling BCP 47 has for it: de, zh, yue, und.
WIDE IN, STRICT OUT. What a container writes is dirty in four separate ways and each has a fold, none of which is a rule invented here — every one is a column of a vendored registry:
| sent | held | the column that did it |
|---|---|---|
DE, De | de | none — ASCII case is a spelling, not a value |
ger (mkv, ISO 639-2/B) | de | registry::alpha3 |
deu (mp4, ISO 639-2/T) | de | the same, in ONE hop rather than through ger |
iw | he | registry::language_preferred |
The two folds are applied in that order and each at most once, so GER reaches de and stops.
See new.
§und is a VALUE, and it is not the absence of one
The registry registers und — Undetermined — like any other subtag, and this type holds it
like any other value. A track whose language nobody recorded has NO language, which is a NULL
column and an Option::None; a track a muxer explicitly tagged und has one, and it says the
muxer looked and could not tell. Collapsing the two would lose the difference between nobody
asked and somebody asked and did not know, and the second is the one that says a detector has
work to do.
UND is how the value is named — an associated constant, which is what the ruling
asked for. It shipped as a function first, and the reason was a fact about the dependency rather
than a preference: smol_bytes::Utf8Bytes::from_static was not const in smol-bytes 0.1.3 —
only Utf8Buffer‘s and RawBytes’ were — so no value of this type could be a const item at
all. smol-bytes 0.1.4 made it const, and the constant took the shape it was always ruled to
have.
One thing the fix did NOT restore: a const still cannot be a MATCH pattern here. Utf8Bytes is
not structural-match, so match language { Language::UND => … } is not available whatever the
constant’s constness — hence is_undetermined, which is the question a
match arm was going to ask.
§A subtag the registry does not carry is ADMITTED
Structure and registration are two questions and this type only refuses on the first. xyz is
three ASCII letters, which is a language subtag’s shape, so it is held — and
is_registered is what says the registry has never heard of it.
Refusing it would be the worse bargain by some distance. The registry gains subtags, a vendored
copy is a snapshot, and a container in the wild carries whatever its muxer believed: refusing
would make a file unindexable because of a table this crate last fetched in August, where
admitting it stores the tag, answers false to the one question that is actually about the
registry, and lets everything else proceed.
The PRIVATE-USE range is the same posture with a name: qaa through qtz are reserved by the
registry as a block and individually registered by nobody, so
is_private_use is what tells a deliberate private tag apart from a
typo. Both answer is_registered() == false, and only the first is intentional.
§Equality is the CANONICAL subtag, so the folds are what make it useful
Language::new("ger")? == Language::new("de")?, because both hold de. That is the whole
point of folding at the door rather than at comparison time: an mkv’s German and an mp4’s German
are one value, one IN list member, one index entry and one group — and nothing downstream has
to know that ISO 639-2 has two alphabets.
It also means a stored column is canonical, which is what lets storage equality BE value
equality: WHERE "language" = 'de' finds the row a ger tag produced.
§Ordering is ALPHABETICAL, and that is all it is
Ord is derived through the text, so de < en < fr. It orders the SPELLINGS and says nothing
about the languages — zh sorts last of those four and is spoken by the most people — which is
the same bargain any single-word vocabulary states for its sort order, and it earns its place
for the same reason: total, stable, and therefore a usable cursor key. gt: "en" with an
ORDER BY on the same column walks a table once with no row seen twice.
Implementations§
Source§impl Language
impl Language
Sourcepub const UND: Self
pub const UND: Self
The undetermined language, und — the value a muxer writes when it looked and could not tell.
An associated constant, as the ruling asked — smol_bytes::Utf8Bytes::from_static became
const in smol-bytes 0.1.4, which is what let this item stop being the function it shipped
as. It allocates nothing — the subtag is three bytes and rides Utf8Bytes’ inline
representation.
Sourcepub fn new(text: &str) -> Result<Self, ParseLanguageError>
pub fn new(text: &str) -> Result<Self, ParseLanguageError>
Read a language subtag, WIDE — any case, and either ISO 639-2 alphabet.
The one door in. Every other route to a value of this type — FromStr,
the GraphQL scalar, the column decode and the cursor — goes through here, so there is one
grammar and one fold rather than one per entry point.
§The grammar, and it is checked BEFORE the registry
Two to eight ASCII letters, which is BCP 47’s language = 2*3ALPHA / 4ALPHA / 5*8ALPHA read
as one range. Anything else is refused, and the refusal names which rule broke rather than
reporting that the input was malformed — see ParseLanguageError.
The ALPHABET is tested before the LENGTH, which is not the order the rules are written in and
is the order that gives the better sentence: 日本語 is 9 bytes, so a length-first check would
refuse it for being too long when what is wrong with it is that a subtag is letters.
§The folds, in order, each at most once
- case — lower, which is the case the registry spells a language in.
- ISO 639-2 to the shortest spelling —
registry::alpha3.geranddeuboth answerde, directly rather than through each other, so this is one hop and not two. - deprecated to preferred —
registry::language_preferred.iwanswershe. One hop is enough by construction: the generator refuses a table in which a preferred value itself prefers something else.
The second and third are applied in sequence rather than as alternatives, so a code that needed both would take both. None does today — every target of the alpha-3 fold is a current two-letter code — and the sequence is what keeps that a fact about the data rather than a premise of the code.
§Errors
ParseLanguageError, naming the rule that refused. Being unregistered is not one of them.
Sourcepub fn is_undetermined(&self) -> bool
pub fn is_undetermined(&self) -> bool
Is this the undetermined language?
The question a match arm would have asked if a value of this type could be a pattern. See
the type docs, where what stands in the way is stated.
Sourcepub fn into_inner(self) -> Utf8Bytes
pub fn into_inner(self) -> Utf8Bytes
The canonical subtag, as the text seat this house carries.
Sourcepub fn name(&self) -> Option<&'static str>
pub fn name(&self) -> Option<&'static str>
The registry’s own name for this language — German, Yue Chinese — or None where it
registers no such subtag.
The FIRST description where the registry gives several: ro is Romanian, which the registry
leads with, and not Moldavian or Moldovan, which it also lists. A name is a label for a
person to read; the identity is the subtag.
Sourcepub fn is_registered(&self) -> bool
pub fn is_registered(&self) -> bool
Does the vendored registry carry this subtag?
false is not an error and never was — see the type docs. It is false for a private-use
subtag too, which is_private_use is what distinguishes.
Sourcepub fn is_deprecated(&self) -> bool
pub fn is_deprecated(&self) -> bool
Has the registry deprecated this subtag?
A canonical value can still be deprecated, which is not a contradiction: 120 deprecated
language subtags name no replacement, so the fold has nowhere to send them and they stay
themselves. iw is never one of these — it prefers he, so a Language never holds it.
Sourcepub fn is_private_use(&self) -> bool
pub fn is_private_use(&self) -> bool
Does this subtag fall in the range the registry reserves for private use, qaa to qtz?
What tells a deliberate private tag apart from a typo, both of which are unregistered.
Sourcepub fn suppressed_script(&self) -> Option<&'static str>
pub fn suppressed_script(&self) -> Option<&'static str>
The script this language implies, where the registry says it implies one.
Suppress-Script, and the reason it is published on the LANGUAGE rather than kept private to
the composition that uses it: it is a fact about the language — English is written in Latin
script — and a caller who wants to know why en-Latn composed as en reads it here.
None for zh, which is what keeps zh-Hans and zh-Hant two different identities.
Trait Implementations§
Source§impl<'a, R: Row> Assemble<'a, R> for Language
Available on crate feature sqlx only.The decode — one TEXT column back through this type’s own door.
impl<'a, R: Row> Assemble<'a, R> for Language
sqlx only.The decode — one TEXT column back through this type’s own door.
Generic over the ROW where the bind is generic over the DIALECT, which is the two traits’ parameters rather than a choice made here.
Source§impl<Db> Carrier<Db> for Language
Available on crate feature sqlx only.The bind: the canonical subtag as text.
impl<Db> Carrier<Db> for Language
sqlx only.The bind: the canonical subtag as text.
An OWNED String rather than the borrowed &str the slot already holds, and the reason
is sqlx::QueryBuilder’s own lifetime rather than a preference. push_bind requires its
value to outlive the builder’s 'args, which this trait’s signature leaves unrelated to
&self — so a borrow of self cannot satisfy it, and the copy is what a bind of borrowed
text costs at this seat. It is at most eight bytes.
Source§fn push_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_bind(&self, qb: &mut QueryBuilder<Db>)
qb. Read moreSource§fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
fn push_value_bind(&self, qb: &mut QueryBuilder<Db>)
Source§impl ColumnEq for Language
A subtag is the same as a subtag when its canonical text is — one column, one comparison.
impl ColumnEq for Language
A subtag is the same as a subtag when its canonical text is — one column, one comparison.
Source§impl ColumnKind for Language
ONE column, which is the default — stated rather than inherited, because a reader auditing
this house against [LanguageId]’s four columns should find the answer here rather than the
absence of one.
impl ColumnKind for Language
ONE column, which is the default — stated rather than inherited, because a reader auditing
this house against [LanguageId]’s four columns should find the answer here rather than the
absence of one.
Source§const SEGMENTS: &'static [ColumnShape] = _
const SEGMENTS: &'static [ColumnShape] = _
Source§const ORDER: &'static [OrderLevel] = _
const ORDER: &'static [OrderLevel] = _
Source§impl CompositeFilterMarker for Language
What guards a Language column, and it is the same predicate at both host kinds.
impl CompositeFilterMarker for Language
What guards a Language column, and it is the same predicate at both host kinds.
A subtag stores every field it declares — there is only the one — so the two seats name one
predicate: ScalarFilter under the reading this crate declares.
Source§type Filter = ScalarFilter<Language, LanguageWire>
type Filter = ScalarFilter<Language, LanguageWire>
Source§type ColumnFilter = ScalarFilter<Language, LanguageWire>
type ColumnFilter = ScalarFilter<Language, LanguageWire>
Source§impl CursorValue for Language
The KEYSET position: the canonical subtag’s UTF-8 bytes, which is what
Utf8Bytes’ own row writes and therefore what a column declared as either pages past.
impl CursorValue for Language
The KEYSET position: the canonical subtag’s UTF-8 bytes, which is what
Utf8Bytes’ own row writes and therefore what a column declared as either pages past.
The read RE-VALIDATES, because a cursor is a string a CLIENT hands back — so a forged position is refused rather than turned into a value whose type says it cannot exist.
Source§impl Debug for Language
Written out rather than derived, so an assertion message reads Language("de") rather than
the Utf8Bytes representation’s own three-field shape.
impl Debug for Language
Written out rather than derived, so an assertion message reads Language("de") rather than
the Utf8Bytes representation’s own three-field shape.
impl DeclaredLeaves for Language
One leaf, and it is the value — ONE column, so there is no sequence to permute.
Source§impl DefaultMarker for Language
The interpretation a Language field is read under: the framework’s COMPOSITE reading, which is the VALUE family’s member for one value occupying a column of its own.
impl DefaultMarker for Language
The interpretation a Language field is read under: the framework’s COMPOSITE reading, which is the VALUE family’s member for one value occupying a column of its own.
This crate used to MINT the marker here — a local marker type with its own
Marker row — because none of the framework’s family words named this
filter, the filter being ScalarFilter under a reading this crate declares.
CompositeMarker is the family that was missing, and the row
above is the answer the mint existed to supply.
Its Marker::UnderOption is
NullableMarker and not the collection reading: a subtag occupies
a column OF ITS OWN, so it can be NULL and the null state is a real observable — a track
whose language nobody recorded is not a track whose language is und.
Source§type Marker = CompositeMarker<Language>
type Marker = CompositeMarker<Language>
Source§impl DelegatesId for Language
THE KEY ROW: this subtag stands at a key position — a record’s #[ingraph(id)], an
aggregate’s #[ingraph(group)] — as the Utf8Bytes it holds.
impl DelegatesId for Language
THE KEY ROW: this subtag stands at a key position — a record’s #[ingraph(id)], an
aggregate’s #[ingraph(group)] — as the Utf8Bytes it holds.
Id is SEALED, so impl Id is not a road for a named type even in this crate:
its members are admitted by MEASUREMENT, and the one door beside that is the transparency
assertion below. Utf8Bytes is a measured member — text, with the filesystem escape a text
segment takes — and this type is that text under a grammar.
§The obligation, checked against what this type actually WRITES
The assertion is that every id duty reading a
Language
reads its Utf8Bytes, and the three duties are the segment, the identity and the order:
- The filesystem segment is
store::fs‘s delegation row, which renders the delegate — so a subtag addresses exactly the file its text addresses. There is no second rendering anywhere in this house to disagree with it:CursorValue::write_cursorabove writesself.as_str().as_bytes(), which is byte for byte whatUtf8Bytes’ own cursor row writes, andCarrier::push_bindbindsself.as_str()as text. - The identity is the derived
PartialEq/Eq/Hash, each of which reads the one field and nothing else — two subtags are equal exactly when theirUtf8Bytesare. - The order is the derived
Ord, through the same field, which is the alphabetical order the type documents.
And the type carries NO second field, tag or width: it is a #[repr(Rust)] newtype over one
Utf8Bytes.
§The FOLD is the door’s, and it strengthens this rather than qualifying it
ger, GER and de are ONE value here, because the fold happens once at construction and
the value that exists afterwards holds de. So the delegate is the FOLDED text, and two
spellings of one identity address one file, key one row and walk one position — which is what
a key needs and what a type folding at comparison time could not give it.
SAFETY: this type is a newtype holding one Utf8Bytes and nothing else — no second field,
no tag, no width of its own. Its equality, hash and order are all derived through that one
field, so two values are equal exactly when their delegates are; delegate is a field
borrow, so it is pure and answers the same inner every time; and every id duty that reads one
reads that text, the segment through the framework’s own delegation row and nothing else
through anything.
Source§impl Display for Language
The canonical subtag, and nothing else — no quotes, no wrapper, no type name.
impl Display for Language
The canonical subtag, and nothing else — no quotes, no wrapper, no type name.
impl Eq for Language
Source§impl From<Language> for LanguageId
A tag with no other seats filled — the shape a bare language subtag composes to.
impl From<Language> for LanguageId
A tag with no other seats filled — the shape a bare language subtag composes to.
Source§impl From<Language> for String
What gives String: TryFrom<[$subtag](
Language
)> through std’s blanket, which is the crossing a storage comparison over a TEXT column
makes — and it makes it with Error = Infallible, a canonical subtag being valid text by
construction.
impl From<Language> for String
What gives String: TryFrom<[$subtag](
Language
)> through std’s blanket, which is the crossing a storage comparison over a TEXT column
makes — and it makes it with Error = Infallible, a canonical subtag being valid text by
construction.
Source§impl InputType for Language
Available on crate feature async-graphql only.
impl InputType for Language
async-graphql only.Source§type RawValueType = Language
type RawValueType = Language
Source§fn create_type_info(registry: &mut Registry) -> String
fn create_type_info(registry: &mut Registry) -> String
Source§fn parse(value: Option<Value>) -> InputValueResult<Self>
fn parse(value: Option<Value>) -> InputValueResult<Self>
Value. None represents undefined.Source§fn as_raw_value(&self) -> Option<&Self::RawValueType>
fn as_raw_value(&self) -> Option<&Self::RawValueType>
Source§fn qualified_type_name() -> String
fn qualified_type_name() -> String
Source§impl MongoCarrier for Language
Available on crate feature mongo only.THE DOCUMENT’S FORM: a BSON String holding the canonical subtag — the same text the
TEXT column above binds, at the one BSON type that holds it.
impl MongoCarrier for Language
mongo only.THE DOCUMENT’S FORM: a BSON String holding the canonical subtag — the same text the
TEXT column above binds, at the one BSON type that holds it.
A subtag is ONE WORD, so there is nothing here of [LanguageId]’s composite question: no
sub-document, no key set, no field order. What the row states is that the two families store
one value — a de row written by SQLite and a de document written by MongoDB carry the same
eight bytes at most — which is what lets one canonicalisation serve both.
BSON’s String order is bytewise over UTF-8, so $gt and $lt over such a field walk the
same alphabetical order the type’s derived Ord walks and the cursor above writes. That is
read from MongoDB’s documented BSON order rather than measured against a live server here,
which is the posture the register takes for its BinData rows.
§What a DOCUMENT can hold is the narrower question, and the answer is Timestamp’s
This row is the FILTER OPERAND’s. The document’s WRITE is serde’s, and no storage type this
crate ships carries a serde row — so a declaration naming a bare
Language
column under mongo(…) is E0277 at the declaration, and the escape is the one
Timestamp’s row names: a type = "…" with its own conversions, which
for a subtag is the String it already converts to and from.
Source§impl MongoExtract for Language
Available on crate feature mongo only.THE READ: the same canonical word, back through the door — [MongoCarrier]’s mirror,
row for row the way query::mongo’s own carrier and extract tables are.
impl MongoExtract for Language
mongo only.THE READ: the same canonical word, back through the door — [MongoCarrier]’s mirror,
row for row the way query::mongo’s own carrier and extract tables are.
A string field is exactly as untrusted as the TEXT column Assemble
above reads: nothing stops a document holding !!!, one written before a registry bump, or
one written by hand for a test. So the read goes through
Language::new
rather than wrapping the bytes, which is what makes it CANONICALISE rather than merely
validate — a document holding GER reads back as de, the value the SQL decode’s own
re-validation produces from the same three letters. See the macro’s own doc for the shape of
what the refusal carries and does not.
Source§impl Ord for Language
impl Ord for Language
1.21.0 (const: unstable) · Source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.21.0 (const: unstable) · Source§fn min(self, other: Self) -> Selfwhere
Self: Sized,
fn min(self, other: Self) -> Selfwhere
Self: Sized,
Source§impl OutputType for Language
Available on crate feature async-graphql only.
impl OutputType for Language
async-graphql only.Source§fn create_type_info(registry: &mut Registry) -> String
fn create_type_info(registry: &mut Registry) -> String
Source§async fn resolve(
&self,
_: &ContextSelectionSet<'_>,
_field: &Positioned<Field>,
) -> ServerResult<Value>
async fn resolve( &self, _: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>
boxed-trait only.async_graphql::Value.Source§fn qualified_type_name() -> String
fn qualified_type_name() -> String
Source§impl PartialOrd for Language
impl PartialOrd for Language
Source§impl ScalarType for Language
Available on crate feature async-graphql only.A BCP 47 primary language subtag, read WIDE and written back canonical: "de", "DE", "ger"
(an mkv’s ISO 639-2/B) and "deu" (an mp4’s 639-2/T) are one operand, and it is written back
as de.
impl ScalarType for Language
async-graphql only.A BCP 47 primary language subtag, read WIDE and written back canonical: "de", "DE", "ger"
(an mkv’s ISO 639-2/B) and "deu" (an mp4’s 639-2/T) are one operand, and it is written back
as de.
"iw" is he, "in" is id — the registry’s Preferred-Value column, applied at the door.
"und" is an ordinary value meaning undetermined, and it is NOT the way to say a track has
no language: an absent language is null, and the difference is between a muxer that looked
and could not tell and a muxer that never looked.
A subtag the registry does not carry is ACCEPTED — the structure is what is checked here, and a
vendored registry is a snapshot. What is refused is a string that is not a subtag’s SHAPE:
zh_CN for its underscore, e for its length, 日本語 for its characters.
Source§fn is_valid(value: &Value) -> bool
fn is_valid(value: &Value) -> bool
The SOLE notion of validity, shared with parse so that a query which
validates is a query which parses. async-graphql’s default answers true for every value,
so a scalar narrowing in parse alone ships a validator admitting what its own parser
rejects — and the refusal then lands at execution rather than at validation, where a client
is looking.
What sharing it costs is the SENTENCE: validation runs before any resolver and reads a
bool, so a client sending a bad operand is told the type its value could not become and
not which rule it broke. The
ParseLanguageError
sentences are what a caller holding a value gets.
Source§fn parse(value: Value) -> InputValueResult<Self>
fn parse(value: Value) -> InputValueResult<Self>
Source§impl ScalarWire<Language> for LanguageWire
impl ScalarWire<Language> for LanguageWire
Source§const NAME: &'static str = "LanguageFilter"
const NAME: &'static str = "LanguageFilter"
T under this reading is published as.Source§type Error = !
type Error = !
Infallible where a crossing cannot refuse.Source§impl<Db> StoredAs<Db> for Language
The DECLARATION: whatever this dialect calls text, since the bind below is a String.
impl<Db> StoredAs<Db> for Language
The DECLARATION: whatever this dialect calls text, since the bind below is a String.
The word is delegated rather than named for the reason the bind is: a subtag IS its canonical text, so the column is a text column and the dialect’s own word for one is the only answer. The delegation carries the ADMISSION with it — a subtag is declarable exactly where text is, which is everywhere.
impl StructuralPartialEq for Language
Source§impl ToGraphqlInput for Language
The crossing is the IDENTITY: this type is its own GraphQL scalar, so an operand needs no
second spelling. Every refusal happens at that scalar’s door, which is the one route a wire
value takes in.
impl ToGraphqlInput for Language
The crossing is the IDENTITY: this type is its own GraphQL scalar, so an operand needs no second spelling. Every refusal happens at that scalar’s door, which is the one route a wire value takes in.
Source§impl ToGraphqlOutput for Language
The crossing OUT, and it is the identity the crossing IN is: this type IS its own GraphQL
scalar, so what a wire face returns is a BORROW of the value the row already holds.
impl ToGraphqlOutput for Language
The crossing OUT, and it is the identity the crossing IN is: this type IS its own GraphQL scalar, so what a wire face returns is a BORROW of the value the row already holds.
The row above says what a client may SEND and this one what a client is GIVEN, and the pair
is what makes a subtag column a whole field type rather than half of one — a filter face with
no return is what ToGraphqlOutput’s own note calls half a field
type. An emitted record’s face returns
<
Language
as ToGraphqlOutput>::Output<'_>, so a declaration storing one could publish NOTHING
without this row: E0277 at the emitted face, naming the member.
&'a Self and never a clone, which is String’s own row’s bargain: the scalar door’s
to_value is what builds the JSON, and it takes a borrow.
The seat is BARE — no OutputType bound is written here — so the row stands in a build with
no GraphQL binding at all, and the library that renders it demands what it needs where it
spends the form. That is the map’s own law rather than a choice made in this house.
Auto Trait Implementations§
impl !Freeze for Language
impl RefUnwindSafe for Language
impl Send for Language
impl Sync for Language
impl Unpin for Language
impl UnsafeUnpin for Language
impl UnwindSafe for Language
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> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
Source§impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
impl<Db, T> DialectCursor<Db> for Twhere
T: CursorValue,
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<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
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
impl<T> Id 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> OrderLeaves for T
impl<T> OrderLeaves for T
Source§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<K> PositionKey for K
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
impl<T> RootKey for T
impl<T> SearchOptionsFace for Twhere
T: InputType,
Source§impl<T> Searchable for T
impl<T> Searchable for T
impl<I> Segment for Iwhere
I: Id + Render,
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.Source§impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
impl<T> WireScore for Twhere
T: ToGraphqlOutput + Send + Sync + 'static,
<T as ToGraphqlOutput>::Output<'a>: for<'a> OutputType,
Source§type Wire<'a> = <T as ToGraphqlOutput>::Output<'a>
where
T: 'a
type Wire<'a> = <T as ToGraphqlOutput>::Output<'a> where T: 'a
async-graphql only.OutputType — the BACKEND’s demand, made where the
backend spends the form.Source§fn wire_score(&self) -> <T as WireScore>::Wire<'_>
fn wire_score(&self) -> <T as WireScore>::Wire<'_>
async-graphql only.