Struct Bare 

pub struct Bare<V: BareValueDomain>(/* private fields */);

Trait Implementations

impl<A: Alignment, V: BareValueDomain> AlignableArity<Bare<V>, A> for Single

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Bare<V>: 'a,

impl<A: Alignment, V: BareValueDomain> AlignableArity<Bare<V>, A> for Definite

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Bare<V>: 'a,

impl<V: BareValueDomain, O: OrderState> BucketFailureArity<Bare<V>> for Multiple<O>

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>

where Bare<V>: 'a,

impl<V: BareValueDomain> BucketFailureArity<Bare<V>> for Single

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>

where Bare<V>: 'a,

impl<V: BareValueDomain> BucketFailureArity<Bare<V>> for Definite

fn bucket_failure<'payload, 'a>( payload: &'payload QueryResult<Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>>, ) -> Option<&'payload Failure>

where Bare<V>: 'a,

impl<V: BareValueDomain> CacheableShape for Bare<V>

type CachedElement = Result<<V as ValueDomain>::Owned, Box<Failure>>

fn into_cached_element(element: Self::Element<'_>) -> Self::CachedElement

fn from_cached_element(cached: &Self::CachedElement) -> Self::Element<'_>

impl ElementKernel<Bare<FailureKindValue>> for ErrorKindNameOperation

type Emission = Preserving

type OutShape = Bare<Scalar>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<FailureKindValue>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl ElementKernel<Bare<FailureValue>> for ErrorKindOperation

type Emission = Preserving

type OutShape = Bare<FailureKindValue>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<FailureValue>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<D: Diagnostic> ElementKernel<Bare<FailureValue>> for IsErrorKindOperation<D>

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<FailureValue>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<G: ErrorGroup> ElementKernel<Bare<FailureValue>> for InErrorGroupOperation<G>

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<FailureValue>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<C: Error + 'static> ElementKernel<Bare<FailureValue>> for HasErrorCauseOperation<C>

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<FailureValue>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<E: EntityDomain> ElementKernel<Bare<IndexValue<E>>> for ResolveOperation

type Emission = Preserving

type OutShape = Bare<EntityReference<E>>

fn pipeline<'a>( graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<IndexValue<E>>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<P: IndexDomain, C: IndexDomain> ElementKernel<Bare<IndexValue<ExpandedIndex<P, C>>>> for ParentIndexOperation

type Emission = Preserving

type OutShape = Bare<IndexValue<P>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<IndexValue<ExpandedIndex<P, C>>>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<P: IndexDomain, C: IndexDomain> ElementKernel<Bare<IndexValue<ExpandedIndex<P, C>>>> for ChildIndexOperation

type Emission = Preserving

type OutShape = Bare<IndexValue<C>>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<IndexValue<ExpandedIndex<P, C>>>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<M> ElementKernel<Bare<Mask>> for AndOperation<M>

where M: ArgumentSource<Unaligned, Mask>,

type Emission = <M as ArgumentSource<Unaligned, Mask>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<Mask>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<M> ElementKernel<Bare<Mask>> for ExclusiveOrOperation<M>

where M: ArgumentSource<Unaligned, Mask>,

type Emission = <M as ArgumentSource<Unaligned, Mask>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<Mask>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl ElementKernel<Bare<Mask>> for NotOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<Mask>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<M> ElementKernel<Bare<Mask>> for OrOperation<M>

where M: ArgumentSource<Unaligned, Mask>,

type Emission = <M as ArgumentSource<Unaligned, Mask>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<Mask>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<S, T> ElementKernel<Bare<S>> for TransitionOperation<T>

where S: ValueTransition<T> + BareValueDomain, T: BareValueDomain,

type Emission = Preserving

type OutShape = Bare<T>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<S>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for AddOperation<A>

where V: ValueAdd + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for DivideOperation<A>

where V: ValueDivide + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for ModuloOperation<A>

where V: ValueModulo + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for MultiplyOperation<A>

where V: ValueMultiply + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for PowerOperation<A>

where V: ValuePower + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for SubtractOperation<A>

where V: ValueSubtract + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for EqualToOperation<A>

where V: ValueEquality + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for GreaterThanOperation<A>

where V: ValueOrdering + BareValueDomain, A: ArgumentSource<Unaligned, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for GreaterThanOrEqualToOperation<A>

where V: ValueOrdering + BareValueDomain, A: ArgumentSource<Unaligned, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for LessThanOperation<A>

where V: ValueOrdering + BareValueDomain, A: ArgumentSource<Unaligned, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for LessThanOrEqualToOperation<A>

where V: ValueOrdering + BareValueDomain, A: ArgumentSource<Unaligned, V>, V::Owned: Debug + Display + Send + Sync,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for NotEqualToOperation<A>

where V: ValueEquality + BareValueDomain, A: ArgumentSource<Unaligned, V>,

type Emission = <A as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, T> ElementKernel<Bare<V>> for CastOperation<T>

where V: ValueCast<T> + BareValueDomain, T: CastTarget,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> ElementKernel<Bare<V>> for ErrorsOperation

type Emission = Dropping

type OutShape = Bare<FailureValue>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> ElementKernel<Bare<V>> for Drop

type Emission = Dropping

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, D: Diagnostic> ElementKernel<Bare<V>> for DropErrorsOf<D>

type Emission = Dropping

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, G: ErrorGroup> ElementKernel<Bare<V>> for DropErrorsIn<G>

type Emission = Dropping

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, C: Error + 'static> ElementKernel<Bare<V>> for DropErrorsWithCause<C>

type Emission = Dropping

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, R> ElementKernel<Bare<V>> for Replace<R>

where V: BareValueDomain, R: ArgumentSource<Unaligned, V>,

type Emission = <R as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, D, R> ElementKernel<Bare<V>> for ReplaceErrorsOf<D, R>

where V: BareValueDomain, D: Diagnostic, R: ArgumentSource<Unaligned, V>,

type Emission = <R as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, G, R> ElementKernel<Bare<V>> for ReplaceErrorsIn<G, R>

where V: BareValueDomain, G: ErrorGroup, R: ArgumentSource<Unaligned, V>,

type Emission = <R as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, C, R> ElementKernel<Bare<V>> for ReplaceErrorsWithCause<C, R>

where V: BareValueDomain, C: Error + 'static, R: ArgumentSource<Unaligned, V>,

type Emission = <R as ArgumentSource<Unaligned, V>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueScalarKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsBoolOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueScalarKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsDateTimeOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueScalarKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsDurationOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueScalarKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsFloatOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsIntOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueScalarKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsNullOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: ValueKindTest + BareValueDomain> ElementKernel<Bare<V>> for IsStringOperation

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for IsInOperation<A>

where V: ValueEquality + BareValueDomain, A: SetSource<V>, for<'a> V::Value<'a>: Eq + Hash,

type Emission = Preserving

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for AbsoluteOperation

where V: ValueAbsolute + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for CeilOperation

where V: ValueCeil + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, L, U> ElementKernel<Bare<V>> for ClipOperation<L, U>

where V: ValueClip + BareValueDomain, L: ArgumentSource<Unaligned, V>, U: ArgumentSource<Unaligned, V>,

type Emission = <<L as ArgumentSource<Unaligned, V>>::Retention as Retention>::Then<<U as ArgumentSource<Unaligned, V>>::Retention>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for CubeRootOperation

where V: ValueCubeRoot + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for ExponentialOperation

where V: ValueExponential + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for FloorOperation

where V: ValueFloor + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for LogarithmOperation

where V: ValueLogarithm + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for NegateOperation

where V: ValueNegate + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for RoundOperation

where V: ValueRound + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for SignOperation

where V: ValueSign + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for SquareRootOperation

where V: ValueSquareRoot + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for ContainsOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for EndsWithOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for LengthOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<Scalar>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for LowercaseOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for MatchesOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, W, C> ElementKernel<Bare<V>> for PadEndOperation<W, C>

where V: StringValue + BareValueDomain, W: ArgumentSource<Unaligned>, W::ValueDomain: IntValue, C: ArgumentSource<Unaligned>, C::ValueDomain: StringValue,

type Emission = <<W as ArgumentSource<Unaligned>>::Retention as Retention>::Then<<C as ArgumentSource<Unaligned>>::Retention>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, W, C> ElementKernel<Bare<V>> for PadStartOperation<W, C>

where V: StringValue + BareValueDomain, W: ArgumentSource<Unaligned>, W::ValueDomain: IntValue, C: ArgumentSource<Unaligned>, C::ValueDomain: StringValue,

type Emission = <<W as ArgumentSource<Unaligned>>::Retention as Retention>::Then<<C as ArgumentSource<Unaligned>>::Retention>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A, B> ElementKernel<Bare<V>> for ReplaceOperation<A, B>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue, B: ArgumentSource<Unaligned>, B::ValueDomain: StringValue,

type Emission = <<A as ArgumentSource<Unaligned>>::Retention as Retention>::Then<<B as ArgumentSource<Unaligned>>::Retention>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A, B> ElementKernel<Bare<V>> for ReplaceAllOperation<A, B>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue, B: ArgumentSource<Unaligned>, B::ValueDomain: StringValue,

type Emission = <<A as ArgumentSource<Unaligned>>::Retention as Retention>::Then<<B as ArgumentSource<Unaligned>>::Retention>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for ReverseOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for SliceOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for SplitOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = Expanding<Ordered>

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for StartsWithOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<Mask>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for StripPrefixOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, A> ElementKernel<Bare<V>> for StripSuffixOperation<A>

where V: StringValue + BareValueDomain, A: ArgumentSource<Unaligned>, A::ValueDomain: StringValue,

type Emission = <A as ArgumentSource<Unaligned>>::Retention

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for TrimOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for TrimEndOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for TrimStartOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V> ElementKernel<Bare<V>> for UppercaseOperation

where V: StringValue + BareValueDomain,

type Emission = Preserving

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, _prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, M> ElementKernel<Bare<V>> for FilterOperation<M>

where V: BareValueDomain, M: ArgumentSource<Unaligned, Mask>,

type Emission = Dropping

type OutShape = Bare<V>

fn pipeline<'a>( _graphrecord: &'a GraphRecord, prepared: Self::Prepared<'a>, ) -> QueryResult<ElementPipeline<'a, Bare<V>, Self>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> ElementShape for Bare<V>

type Element<'a> = Result<<V as ValueDomain>::Value<'a>, Box<Failure>>

type ValueDomain = V

impl<I: IndexDomain, V: ValueDomain, W: BareValueDomain, E: ElementEmission> ElementTransition<Bare<W>, E> for Indexed<I, V>

type Pipeline<'a> = Pipeline<'a, (<I as IndexDomain>::Index<'a>, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>), <E as ElementEmission>::Step<Result<<W as ValueDomain>::Value<'a>, Box<Failure>>>, E>

fn apply<'a, C: Arity>( values: C::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <E::OutArity<C> as Arity>::Container<'a, <Bare<W> as ElementShape>::Element<'a>>

impl<V: BareValueDomain, W: BareValueDomain, E: ElementEmission> ElementTransition<Bare<W>, E> for Bare<V>

type Pipeline<'a> = Pipeline<'a, Result<<V as ValueDomain>::Value<'a>, Box<Failure>>, <E as ElementEmission>::Step<Result<<W as ValueDomain>::Value<'a>, Box<Failure>>>, E>

fn apply<'a, C: Arity>( values: C::Container<'a, Self::Element<'a>>, pipeline: Self::Pipeline<'a>, ) -> <E::OutArity<C> as Arity>::Container<'a, <Bare<W> as ElementShape>::Element<'a>>

impl<E: EntityDomain> LaneKernel<Bare<EntityReference<E>>, Definite> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, EntityReference<E>, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<E: EntityDomain, O: OrderState> LaneKernel<Bare<EntityReference<E>>, Multiple<O>> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, EntityReference<E>, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<E: EntityDomain> LaneKernel<Bare<EntityReference<E>>, Single> for SelectOperation

type Output = OperandHandle<Indexed<E, Unit>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, EntityReference<E>, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Bare<Mask>, Multiple<O>> for AllOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<O: OrderState> LaneKernel<Bare<Mask>, Multiple<O>> for AnyOperation

type Output = OperandHandle<Bare<Mask>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, Mask, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Definite> for CountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Definite> for Raise

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, C> LaneKernel<Bare<V>, Definite> for RaiseWhen<C>

where V: BareValueDomain, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, D: Diagnostic> LaneKernel<Bare<V>, Definite> for RaiseErrorsOf<D>

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, G: ErrorGroup> LaneKernel<Bare<V>, Definite> for RaiseErrorsIn<G>

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, E: Error + 'static> LaneKernel<Bare<V>, Definite> for RaiseErrorsWithCause<E>

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, D, C> LaneKernel<Bare<V>, Definite> for RaiseWhenErrorsOf<D, C>

where V: BareValueDomain, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, G, C> LaneKernel<Bare<V>, Definite> for RaiseWhenErrorsIn<G, C>

where V: BareValueDomain, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, E, C> LaneKernel<Bare<V>, Definite> for RaiseWhenErrorsWithCause<E, C>

where V: BareValueDomain, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Definite>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Definite>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for CountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MaximumOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MeanOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MedianOperation

where V: ValueMedian + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for MinimumOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueMode + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for ModeOperation

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for ProductOperation

where V: ValueMultiply + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for RandomOperation

where V: BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for StandardDeviationOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for SumOperation

where V: ValueAdd + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UniqueCountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for VarianceOperation

where V: ValueScalar + BareValueDomain, O: OrderState,

type Output = OperandHandle<Bare<Scalar>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for Raise

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhen<C>

where V: BareValueDomain, O: OrderState, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, D: Diagnostic> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsOf<D>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, G: ErrorGroup> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsIn<G>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState, E: Error + 'static> LaneKernel<Bare<V>, Multiple<O>> for RaiseErrorsWithCause<E>

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, D, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsOf<D, C>

where V: BareValueDomain, O: OrderState, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, G, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsIn<G, C>

where V: BareValueDomain, O: OrderState, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O, E, C> LaneKernel<Bare<V>, Multiple<O>> for RaiseWhenErrorsWithCause<E, C>

where V: BareValueDomain, O: OrderState, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for ShuffleOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, O> LaneKernel<Bare<V>, Multiple<O>> for SortOperation

where V: ValueOrdering + BareValueDomain, O: OrderState, for<'a> V::Value<'a>: EnsureSortable, V::Owned: Debug + Display + Send + Sync,

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UnorderOperation

type Output = OperandHandle<Bare<V>, Multiple<Unordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for IsDuplicatedOperation

type Output = OperandHandle<Bare<Mask>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: ValueEquivalence + BareValueDomain, O: OrderState> LaneKernel<Bare<V>, Multiple<O>> for UniqueOperation

type Output = OperandHandle<Bare<V>, Multiple<O>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<O>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for EnumerateOperation

type Output = OperandHandle<Indexed<Positional, V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for FirstOperation

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for LastOperation

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for ReverseOrderOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Multiple<Ordered>> for TakeOperation

type Output = OperandHandle<Bare<V>, Multiple<Ordered>>

fn execute<'a>( _graphrecord: &'a GraphRecord, values: BareStream<'a, V, Multiple<Ordered>>, prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Single> for CountOperation

type Output = OperandHandle<Bare<Scalar>, Definite>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, _input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain> LaneKernel<Bare<V>, Single> for Raise

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, C> LaneKernel<Bare<V>, Single> for RaiseWhen<C>

where V: BareValueDomain, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, D: Diagnostic> LaneKernel<Bare<V>, Single> for RaiseErrorsOf<D>

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, G: ErrorGroup> LaneKernel<Bare<V>, Single> for RaiseErrorsIn<G>

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, E: Error + 'static> LaneKernel<Bare<V>, Single> for RaiseErrorsWithCause<E>

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( _graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, _prepared: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, D, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsOf<D, C>

where V: BareValueDomain, D: Diagnostic, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, G, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsIn<G, C>

where V: BareValueDomain, G: ErrorGroup, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V, E, C> LaneKernel<Bare<V>, Single> for RaiseWhenErrorsWithCause<E, C>

where V: BareValueDomain, E: Error + 'static, C: ArgumentSource<Unaligned, Mask, Retention = Preserving>,

type Output = OperandHandle<Bare<V>, Single>

fn execute<'a>( graphrecord: &'a GraphRecord, value: BareStream<'a, V, Single>, condition: Self::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

fn estimate(&self, input: Estimate, _stats: &Stats<'_>) -> Estimate

impl<V: BareValueDomain, O: OrderState> PreparedArity<Bare<V>> for Multiple<O>

type Prepared<'a> = Arc<Vec<Result<<V as ValueDomain>::Value<'a>, Box<Failure>>>> where Bare<V>: 'a

fn prepare<'a>( container: Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>

where Bare<V>: 'a,

impl<V: BareValueDomain> PreparedArity<Bare<V>> for Single

type Prepared<'a> = Option<Result<<V as ValueDomain>::Value<'a>, Box<Failure>>> where Bare<V>: 'a

fn prepare<'a>( container: Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>

where Bare<V>: 'a,

impl<V: BareValueDomain> PreparedArity<Bare<V>> for Definite

type Prepared<'a> = Result<<V as ValueDomain>::Value<'a>, Box<Failure>> where Bare<V>: 'a

fn prepare<'a>( container: Self::Container<'a, <Bare<V> as ElementShape>::Element<'a>>, ) -> QueryResult<Self::Prepared<'a>>

where Bare<V>: 'a,

impl<V: BareValueDomain + ReturnValueDomain> ReturnShape for Bare<V>

type ReturnElement<'a> = Result<<V as ValueDomain>::Value<'a>, Box<Failure>>

fn into_return_element(element: Self::Element<'_>) -> Self::ReturnElement<'_>

impl<V, O> SetArity<Bare<V>> for Multiple<O>

where V: BareValueDomain, O: OrderState, for<'a> V::Value<'a>: Eq + Hash,

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>

where Bare<V>: 'a,

impl<V> SetArity<Bare<V>> for Single

where V: BareValueDomain, for<'a> V::Value<'a>: Eq + Hash,

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>

where Bare<V>: 'a,

impl<V> SetArity<Bare<V>> for Definite

where V: BareValueDomain, for<'a> V::Value<'a>: Eq + Hash,

fn set<'a>(prepared: Self::Prepared<'a>) -> QueryResult<GrHashSet<V::Value<'a>>>

where Bare<V>: 'a,