Skip to main content

ListFilter

Struct ListFilter 

Source
pub struct ListFilter<T, VF = <<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter> { /* private fields */ }
Expand description

The sequence filter — for an ORDERED collection column, generic over the element type T. eq/ne compare the whole collection element by element, so [1, 2] and [2, 1] are different operands; gt/gte/lt/lte compare it lexicographically; has_element is membership.

§The set operators are SetFilter’s, and that is the whole of the split

This kind carried encloses, enclosed_by and overlaps under a shape parameter naming the column ordered or unordered. All three ignore order and multiplicity, so they read a list as a set whatever the parameter said, and the parameter decided one operator: what eq MEANT. Five of six operators were set semantics, which is a second kind rather than a second rendering.

Postgres draws the same line in its own operator table — @> / <@ / && are the set operators and = is the sequence one, so ARRAY[1,1,2] @> ARRAY[1] holds while ARRAY[1,2] = ARRAY[2,1] does not.

has_element is on BOTH kinds. Membership is order- and multiplicity-blind like the three that left, but it is the one question about a single element a sequence still answers, and a sequence filter without it would send a caller to a whole-collection operator for it.

§The four ordering operators are not answerable everywhere, and the filter still carries them

gt/gte/lt/lte compare whole collections ELEMENT-WISE and lexicographically, which is what a Postgres array’s own < does. Neither of the other two SQL dialects has that operator for a collection kept in a COLUMN: both store one as JSON, and JSON’s ordering — where it exists at all — ranks by element TYPE before value, so adopting it would answer a different question under the same name. Stored in an edge table those two answer the four exactly, because an ordinal column is the thing that was missing.

A filter is BACKEND-NEUTRAL, so the operators live here whole and the refusal lives at the crossing, where the dialect and the storage strategy are both known — see ListCrossingError. That is the arrangement BytesFilter already uses for its fixed-width substring refusal: a vocabulary that is smaller on one backend is not a smaller filter type, it is a typed no at the boundary.

§VF is the ELEMENT’s filter, and it is what any asks with

The second parameter is the filter kind ONE element of this collection is guarded by, and it defaults to the element type’s own reading — <<T as DefaultMarker>::Marker as ToGraphqlFilter>::Filter, the same projection a scalar column of T resolves through. So ListFilter<i64> is ListFilter<i64, ScalarFilter<i64>> and nothing that spelled the one parameter has to learn the second.

A DEFAULT rather than a bound, because T need not have a reading at all: an element type with no DefaultMarker row is still filterable by naming VF outright, which is the shape a downstream collection of a foreign element type takes.

§has_element is any: { eq: … }, and it stays

has_element: x and any: { eq: x } are the same question, and the second subsumes the first the moment the element’s filter has an equality — which every kind this crate ships does. What keeps the older spelling is that it is the one a caller reaches for, and that removing an operator from a wire face is a breaking change for a client that never asked for the general form. The overlap is real and is stated rather than resolved.

The two are not the same RENDERING. has_element lowers as containment of the singleton — one operand, one bind, an index seek on every strategy — while any opens an element scope and applies a whole comparison inside it. Where both express a question, the narrower one is the cheaper plan.

§The polarsync COVERAGE AUDIT, per operator

polarsync is the reference this crate’s collection surface was measured against, and its whole collection vocabulary is ONE type: ArrayFilter<I> with nine operators, OptionalArrayFilter<I> adding a tenth. It draws no sequence/set line at all — Vec<H<N>> and Vec<String> both reach the same filter — so the audit is that one list against this crate’s two kinds.

polarsyncits Postgres operatorhere
eq=eq, on both kinds
not<>ne, on both kinds
gt / gte / lt / lte> >= < <=this type’s four; a set has no ordering to ask about
contains@>SetFilter’s encloses
is_contained_by<@SetFilter’s enclosed_by
overlaps&&SetFilter’s overlaps
null, on the optional formIS NULLNOT HERE, by ruling — a collection has no null state, and is it empty is count: { eq: 0 }
——has_element, any and count have no counterpart there at all

Every operator is covered, and what differs is which KIND carries it. The three set operators are on SetFilter here, so a column declared set(…) has polarsync’s whole vocabulary and a column declared list(…) has its ordering half. That is the split this type’s own note argues for — five of six operators under the old shape parameter were set semantics — and moving them back would be a RULING about what a sequence MEANS rather than a lowering nobody wrote: all three already lower on every dialect and both storage strategies, through SqlSetComparison, SqlEdgeSetComparison and MongoSetComparison, so whatever answers that question spends no new machinery.

The other direction is where this crate is wider, and the widest of the three is any: polarsync can ask does this array contain exactly this value and cannot ask does some element of it satisfy this filter, which is the element scope any opens.

§count is a whole scalar filter, and usize is what a length is

A cardinality is asked with the eight operators a number is asked — count: { gt: 3 }, count: { in: [1, 2] } — rather than with a bare equality, because how many is an ordered question and half of what a caller wants to say about one is a bound rather than a value.

The operand is a usize because a collection’s LENGTH is one: Vec::len returns it, and the number this operator compares against is the same number. The platform dependence is therefore the operand’s own rather than something the filter introduced — see the wire name that follows from it, CountFilter, in this module’s registration table.

Implementations§

Source§

impl<T, VF> ListFilter<T, VF>

Source

pub const fn new() -> Self

The empty filter — no operator set.

Source

pub const fn is_empty(&self) -> bool

True while NO operator slot is set — so a lowering would emit nothing for this field.

Inherent, not the backend traits’ provided is_empty: “is anything set” is a property of the FILTER, identical on every backend, and asking it should not make a caller name a dialect (with two families compiled, f.is_empty() through the traits is E0283). The inherent method wins method resolution, so every call site reads the same either way.

§The two nested slots answer the empty case differently, and the QUANTIFIER is the whole reason

A present any holding an EMPTY element filter is not empty: every element satisfies the empty filter, so some element satisfies it is this collection has an element. ∃x ∈ S. true is S ≠ ∅, which is a predicate and not the absence of one.

A present count holding an empty scalar filter IS empty, because nothing quantifies it — asking no question about one number excludes no row. That is Nullable’s fold-in, which is this crate’s rule for a nested filter; the element slot is the one exception and it is the quantifier that earns it.

Source

pub fn eq(&self) -> Option<&[T]>

The eq operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_eq(self, value: impl Into<Box<[T]>>) -> Self

Set eq to Some(value) (consuming).

Source

pub fn set_eq(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set eq to Some(value) (in place).

Source

pub fn maybe_eq(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the eq list option (consuming).

Source

pub fn update_eq(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the eq list option (in place).

Source

pub fn ne(&self) -> Option<&[T]>

The ne operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_ne(self, value: impl Into<Box<[T]>>) -> Self

Set ne to Some(value) (consuming).

Source

pub fn set_ne(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set ne to Some(value) (in place).

Source

pub fn maybe_ne(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the ne list option (consuming).

Source

pub fn update_ne(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the ne list option (in place).

Source

pub fn gt(&self) -> Option<&[T]>

The gt operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_gt(self, value: impl Into<Box<[T]>>) -> Self

Set gt to Some(value) (consuming).

Source

pub fn set_gt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set gt to Some(value) (in place).

Source

pub fn maybe_gt(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the gt list option (consuming).

Source

pub fn update_gt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the gt list option (in place).

Source

pub fn gte(&self) -> Option<&[T]>

The gte operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_gte(self, value: impl Into<Box<[T]>>) -> Self

Set gte to Some(value) (consuming).

Source

pub fn set_gte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set gte to Some(value) (in place).

Source

pub fn maybe_gte(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the gte list option (consuming).

Source

pub fn update_gte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the gte list option (in place).

Source

pub fn lt(&self) -> Option<&[T]>

The lt operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_lt(self, value: impl Into<Box<[T]>>) -> Self

Set lt to Some(value) (consuming).

Source

pub fn set_lt(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set lt to Some(value) (in place).

Source

pub fn maybe_lt(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the lt list option (consuming).

Source

pub fn update_lt(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the lt list option (in place).

Source

pub fn lte(&self) -> Option<&[T]>

The lte operands, or None while the operator is absent.

A PRESENT but empty list is not the same as an absent operator: the first asks for no rows, the second for every row, so Some(&[]) and None say different things.

Source

pub fn with_lte(self, value: impl Into<Box<[T]>>) -> Self

Set lte to Some(value) (consuming).

Source

pub fn set_lte(&mut self, value: impl Into<Box<[T]>>) -> &mut Self

Set lte to Some(value) (in place).

Source

pub fn maybe_lte(self, value: Option<impl Into<Box<[T]>>>) -> Self

Assign the lte list option (consuming).

Source

pub fn update_lte(&mut self, value: Option<impl Into<Box<[T]>>>) -> &mut Self

Assign the lte list option (in place).

Source

pub const fn has_element(&self) -> Option<&T>

The has_element operand, or None while the operator is absent.

Source

pub fn with_has_element(self, value: T) -> Self

Set has_element to Some(value) (consuming).

Source

pub fn set_has_element(&mut self, value: T) -> &mut Self

Set has_element to Some(value) (in place).

Source

pub fn maybe_has_element(self, value: Option<T>) -> Self

Assign the raw has_element option (consuming).

Source

pub fn update_has_element(&mut self, value: Option<T>) -> &mut Self

Assign the raw has_element option (in place).

Source

pub const fn any(&self) -> Option<&VF>

The any operand, or None while the operator is absent.

Source

pub fn with_any(self, value: VF) -> Self

Set any to Some(value) (consuming).

Source

pub fn set_any(&mut self, value: VF) -> &mut Self

Set any to Some(value) (in place).

Source

pub fn maybe_any(self, value: Option<VF>) -> Self

Assign the raw any option (consuming).

Source

pub fn update_any(&mut self, value: Option<VF>) -> &mut Self

Assign the raw any option (in place).

Source

pub const fn count(&self) -> Option<&ScalarFilter<usize>>

The count operand, or None while the operator is absent.

Source

pub fn with_count(self, value: ScalarFilter<usize>) -> Self

Set count to Some(value) (consuming).

Source

pub fn set_count(&mut self, value: ScalarFilter<usize>) -> &mut Self

Set count to Some(value) (in place).

Source

pub fn maybe_count(self, value: Option<ScalarFilter<usize>>) -> Self

Assign the raw count option (consuming).

Source

pub fn update_count(&mut self, value: Option<ScalarFilter<usize>>) -> &mut Self

Assign the raw count option (in place).

Source

pub fn try_map<U, E, F>(self, f: F) -> Result<ListFilter<U, VF>, E>
where F: FnMut(T) -> Result<U, E>,

Convert every ELEMENT operand with f, keeping the operator set exactly as it stands — see ScalarFilter::try_map for what this primitive is for and what it promises about lists.

f maps ONE ELEMENT, not a collection. Six of the seven element slots hold a whole collection operand and the seventh a single element, and both are made of the same T — so a single element converter serves all seven, and has_element is not a special case.

any and count pass through UNTOUCHED. Each holds a whole FILTER rather than an operand, and this method’s parameter ranges over T — so a nested filter’s own operands are converted by its own crossing, which is the same division Nullable::try_map draws between the wrapper and the kind it wraps. count’s operands are not made of T at all: a length is a usize whatever the elements are.

Trait Implementations§

Source§

impl<T: Clone, VF: Clone> Clone for ListFilter<T, VF>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<T: Debug, VF: Debug> Debug for ListFilter<T, VF>

Source§

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

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

impl<T, VF> Default for ListFilter<T, VF>

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<T, VF> GraphqlFilter for ListFilter<T, VF>

Source§

fn is_empty(&self) -> bool

True while NO operator slot is set — so a lowering would emit nothing for this field.
Source§

impl<T, VF> InputObjectType for ListFilter<T, VF>

Available on crate feature async-graphql only.
Source§

impl<T, VF> InputType for ListFilter<T, VF>

Available on crate feature async-graphql only.

The WIRE FACE, written over the two PARAMETERS rather than per instantiation.

§One row where there was a table, and the table is what pins it

A sequence column’s face used to be a hand-maintained row per element type — eleven of them, each naming its own SDL string. Every one of those rows is reproduced by this impl, name for name, and the elements the table could not reach are reached too: a declarer’s own vocabulary (ListFilter<Tag, EnumFilter<Tag>>), and the gated types the table deliberately left out. That is what makes it ONE row rather than a wider table — a collection’s face is a fact about the element’s face, and the element’s face is already registered.

Nothing is orphaned by it. ListFilter is this crate’s own type, so the impl is LOCAL at every pair of parameters; a declaring crate supplies its element’s face and its element filter’s, both impls on its own types, and this row does the rest.

§The bounds are the two faces the body spends, and nothing more

T: ToGraphqlInput because six operator slots hold Box<[T]> and one holds a bare T, and what goes on the wire for each is the ELEMENT’S CROSSING — not the element. That bound is what a plain T: InputType cost: u128 has no InputType in any crate but async-graphql’s, so a Vec<u128> column could not reach a schema at all, and Vec<u8> has one that renders [Int!], so a Vec<Vec<u8>> column reached a schema that LIED — a list of lists of small integers where the same blob’s own filter published hex. Both are the element’s own crossing here.

VF: InputType because any holds the element’s own filter, and because the schema NAME is derived from it — see operand_of for why the element’s own name cannot serve. ScalarFilter<usize> needs no bound: count is a cardinality, so it is one registered input object for every element type there is.

T::Input: InputType IS async-graphql’s demand on the crossed form, and it is written here rather than on ToGraphqlInput’s seat because that is the law: the map says which form an element crosses as, and each backend asks what it needs of that form where it SPENDS it. An element whose crossing this library cannot parse is E0277 at this face, and its row stays legal for a second binding to read.

T: Send + Sync is not a further face — it is InputType’s own supertrait, asked of Self and reaching T through the Option<T> slots. It used to arrive free with T: InputType and is restated now that the element’s bound is this crate’s own trait. Every element that could ever have reached a schema already satisfied it.

§What the table’s own rules were, and which of them the row keeps

The four ORDERING fields are on the wire for every element type, including the ones whose only compiled backend cannot answer them. A filter is backend-neutral and a schema is rendered without naming a dialect, so the alternative would be a wire face that varied with a Cargo feature — a client’s schema changing because a server was rebuilt. The refusal is the CROSSING’s, and it names the operator.

any renders as the ELEMENT’s own input object — I64ListFilter.any is an I64Filter — so nothing new is registered for it: the element’s value filter is already on the wire, which is what makes Vec<T> reach a schema exactly when T does. count renders as CountFilter whatever the element is, a cardinality having no operand to be named after.

Two of the table’s rows were ABSENCES with reasons, and this row answers both by construction rather than by discipline. ListFilter<u8> had no row because a Vec<u8> is a BLOB here, so no field’s default resolves to it and an input object for it would be unreachable — and an impl is REGISTERED only where a field names it, so UInt8ListFilter still reaches no schema. The gated temporal and text vocabularies had none because giving one to them alone would have made them the exception among the gated rows — and now none of them is an exception: a Vec<Timestamp> column resolves to ListFilter<Timestamp> and reaches a schema as DateTimeListFilter, closing the gap filter’s own note used to describe as designed.

Source§

type RawValueType = ListFilter<T, VF>

The raw type used for validator. Read more
Source§

fn type_name() -> Cow<'static, str>

Type the name.
Source§

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.
Source§

fn parse(value: Option<Value>) -> InputValueResult<Self>

Parse from Value. None represents undefined.
Source§

fn to_value(&self) -> Value

Convert to a Value for introspection.
Source§

fn as_raw_value(&self) -> Option<&Self::RawValueType>

Returns a reference to the raw value.
Source§

fn qualified_type_name() -> String

Qualified typename.
Source§

impl<T, VF> NullableFace for ListFilter<T, VF>

Available on crate feature async-graphql only.

The NULLABLE row, fed from the same face for the reason filter_input_object! feeds one from every invocation: nullability is a TYPE here, so a face with no NullableFace leaves every Option<Vec<T>> column unspellable.

The twin the blanket assembles is flat, and its parse hands the SAME object to the bare face’s own — so the nine operator fields keep exactly one parser.

Source§

fn bare_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>

This face’s input fields, in the order it publishes them — the list the nullable twin registers with isNull appended.
Source§

fn bare_values(&self) -> IndexMap<Name, Value>

This face’s rendered slots, in that same order — the map the nullable twin renders with isNull appended.
Source§

impl<T: PartialEq, VF: PartialEq> PartialEq for ListFilter<T, VF>

Source§

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

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

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

Inequality operator !=. Read more
Source§

impl<T: PartialEq, VF: PartialEq> StructuralPartialEq for ListFilter<T, VF>

Source§

impl<D, VF, V, Db: CollectionStorage<V, VF>> ToDatabaseComparison<V, Db> for ListFilter<D, VF>

Available on crate feature sqlx only.

The type-level map, keyed on the dialect’s declared strategy: a ListFilter crosses into whichever comparison the database that answers keeps a SEQUENCE in.

It is the crossing where the choice lands rather than anything below it, because ToDatabaseComparison’s Comparison is already keyed on Db. Nothing about ComplexComparison changes and no other filter kind pays for it.

§The element filter crosses FIRST, and the collection reads its answer

VF is the element’s filter kind, and the comparison the collection holds is whatever THAT filter crosses into over the SAME storage type and the same dialect — because a collection’s members are stored as V, whether in a column, an array or an edge row. So this row projects through VF’s own crossing and hands the result to the storage map, which is what keeps the element’s vocabulary the element’s: a text element brings the substring family and a scalar one does not, with nothing here choosing between them.

Source§

type Comparison = <Db as CollectionStorage<V, VF>>::Sequence

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>

Available on crate feature mongo only.

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: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for MongoListComparison<V, C>

Available on crate feature mongo only.

The identity crossing for a sequence — a Vec<String> stored as an array of strings is the common one.

Source§

type Error = MongoCollectionCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>

Why a filter’s operands did not become storage values.
Source§

fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>

Cross filter into this comparison, or report why an operand could not follow.
Source§

impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, MySql>

Available on crate features mysql and sqlx only.
Source§

type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>

Why a filter’s operands did not become storage values.
Source§

fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>

Cross filter into this comparison, or report why an operand could not follow.
Source§

impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Postgres>

Available on crate features postgres and sqlx only.

The identity crossing for a Postgres sequence column — a Vec<String> stored as a text[] is the common one.

Source§

type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>

Why a filter’s operands did not become storage values.
Source§

fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>

Cross filter into this comparison, or report why an operand could not follow.
Source§

impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>> for SqlListComparison<V, C, Sqlite>

Available on crate features sqlite and sqlx only.
Source§

type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>

Why a filter’s operands did not become storage values.
Source§

fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>

Cross filter into this comparison, or report why an operand could not follow.
Source§

impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>, Db> TryFromFilter<ListFilter<D, VF>> for SqlEdgeComparison<V, C, Db>

Available on crate feature sqlx only.

The identity crossing for an edge-table sequence — a Vec<String> whose elements are stored as TEXT is the common one.

This is the impl the whole At design exists to make writable, and it is generic over the dialect because the crossing is: which strategy stores a collection is CollectionStorage’s answer, and by the time a filter reaches here it has been given.

§Errors

As try_from_filter_with_element.

Source§

type Error = ListCrossingError<<V as TryFrom<D>>::Error, <C as TryFromFilter<VF>>::Error>

Why a filter’s operands did not become storage values.
Source§

fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error>

Cross filter into this comparison, or report why an operand could not follow.

Auto Trait Implementations§

§

impl<T, VF> Freeze for ListFilter<T, VF>
where Option<Box<[T]>>: Freeze, Option<T>: Freeze, Option<VF>: Freeze,

§

impl<T, VF> RefUnwindSafe for ListFilter<T, VF>

§

impl<T, VF> Send for ListFilter<T, VF>
where Option<Box<[T]>>: Send, Option<T>: Send, Option<VF>: Send,

§

impl<T, VF> Sync for ListFilter<T, VF>
where Option<Box<[T]>>: Sync, Option<T>: Sync, Option<VF>: Sync,

§

impl<T, VF> Unpin for ListFilter<T, VF>
where Option<Box<[T]>>: Unpin, Option<T>: Unpin, Option<VF>: Unpin,

§

impl<T, VF> UnsafeUnpin for ListFilter<T, VF>

§

impl<T, VF> UnwindSafe for ListFilter<T, VF>

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> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
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<C> FlattenFace for C
where C: NullableFace,

Source§

fn flat_read<F>( object: &IndexMap<Name, ConstValue>, ) -> Result<C, InputValueError<F>>
where F: InputType,

Available on crate feature async-graphql only.

The object is CLONED, and the clone is the honest cost of splicing: the component’s parser takes an owned value, and the host’s other fields are read off the same object either side of this call. Handing the last splice the owned map would save one clone in the one-splice case and make the emission depend on which field came last.

Source§

fn flat_fields(registry: &mut Registry) -> IndexMap<String, MetaInputValue>

Available on crate feature async-graphql only.
The fields this component contributes to its host’s registration.
Source§

fn flat_values(&self) -> IndexMap<Name, ConstValue>

Available on crate feature async-graphql only.
The rendered slots this component contributes to its host’s render, in the order it publishes them.
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> SearchOptionsFace for T
where T: InputType,

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<F, V, Db> ToCrossedComparison<V, Db> for F

Source§

fn cross( self, ) -> Result<<F as ToDatabaseComparison<V, Db>>::Comparison, Box<dyn Error + Send + Sync>>

Cross this filter into the comparison the map names for it. Read more
Source§

fn empty() -> <F as ToDatabaseComparison<V, Db>>::Comparison

The EMPTY comparison of this kind: what a column the client said nothing about lowers to. Read more
Source§

impl<F, V, Db> ToFlattenedComparison<V, Db> for F

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

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

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

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

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