Struct legion_core::filter::Or

pub struct Or<T> {
    pub filters: T,
}

A filter which requires that any filter within T match.

Fields

filters: T

Trait Implementations

impl<A, B> ActiveFilter for Or<(A, B)>

impl<A, B, C> ActiveFilter for Or<(A, B, C)>

impl<A, B, C, D, E, F, G, H, I, J, K, L> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

impl<A, B, C, D> ActiveFilter for Or<(A, B, C, D)>

impl<A, B, C, D, E> ActiveFilter for Or<(A, B, C, D, E)>

impl<A, B, C, D, E, F> ActiveFilter for Or<(A, B, C, D, E, F)>

impl<A, B, C, D, E, F, G> ActiveFilter for Or<(A, B, C, D, E, F, G)>

impl<A, B, C, D, E, F, G, H> ActiveFilter for Or<(A, B, C, D, E, F, G, H)>

impl<A, B, C, D, E, F, G, H, I> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I)>

impl<A, B, C, D, E, F, G, H, I, J> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J)>

impl<A, B, C, D, E, F, G, H, I, J, K> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K)>

impl<A, B> BitAnd<Passthrough> for Or<(A, B)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C> BitAnd<Passthrough> for Or<(A, B, C)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J, K, L> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D> BitAnd<Passthrough> for Or<(A, B, C, D)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E> BitAnd<Passthrough> for Or<(A, B, C, D, E)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F> BitAnd<Passthrough> for Or<(A, B, C, D, E, F)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J, K> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, I, J, K, Rhs: ActiveFilter> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = And<(Self, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B> BitOr<Passthrough> for Or<(A, B)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C> BitOr<Passthrough> for Or<(A, B, C)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J, K, L> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D> BitOr<Passthrough> for Or<(A, B, C, D)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E> BitOr<Passthrough> for Or<(A, B, C, D, E)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F> BitOr<Passthrough> for Or<(A, B, C, D, E, F)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J, K> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B)>

type Output = Or<(A, B, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C)>

type Output = Or<(A, B, C, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J, K, L, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D)>

type Output = Or<(A, B, C, D, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E)>

type Output = Or<(A, B, C, D, E, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F)>

type Output = Or<(A, B, C, D, E, F, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G)>

type Output = Or<(A, B, C, D, E, F, G, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H)>

type Output = Or<(A, B, C, D, E, F, G, H, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I)>

type Output = Or<(A, B, C, D, E, F, G, H, I, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, I, J, K, Rhs: ActiveFilter> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<T: Clone> Clone for Or<T>

fn clone(&self) -> Or<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Or<T>

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

Formats the value using the given formatter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>> Filter<T> for Or<(A, B)>

type Iter = FissileZip<A::Iter, B::Iter>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>> Filter<T> for Or<(A, B, C)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, C::Iter>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, K: Filter<T>, L: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, FissileZip<G::Iter, FissileZip<H::Iter, FissileZip<I::Iter, FissileZip<J::Iter, FissileZip<K::Iter, L::Iter>>>>>>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>> Filter<T> for Or<(A, B, C, D)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, D::Iter>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>> Filter<T> for Or<(A, B, C, D, E)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, E::Iter>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, F::Iter>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, G::Iter>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G, H)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, FissileZip<G::Iter, H::Iter>>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G, H, I)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, FissileZip<G::Iter, FissileZip<H::Iter, I::Iter>>>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, FissileZip<G::Iter, FissileZip<H::Iter, FissileZip<I::Iter, J::Iter>>>>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T: Copy, A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, K: Filter<T>> Filter<T> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Iter = FissileZip<A::Iter, FissileZip<B::Iter, FissileZip<C::Iter, FissileZip<D::Iter, FissileZip<E::Iter, FissileZip<F::Iter, FissileZip<G::Iter, FissileZip<H::Iter, FissileZip<I::Iter, FissileZip<J::Iter, K::Iter>>>>>>>>>>

fn init(&self)

fn collect(&self, source: T) -> Self::Iter

Pulls iterator data out of the source.

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<A, B> Not for Or<(A, B)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C> Not for Or<(A, B, C)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G, H, I, J, K, L> Not for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D> Not for Or<(A, B, C, D)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E> Not for Or<(A, B, C, D, E)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F> Not for Or<(A, B, C, D, E, F)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G> Not for Or<(A, B, C, D, E, F, G)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G, H> Not for Or<(A, B, C, D, E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G, H, I> Not for Or<(A, B, C, D, E, F, G, H, I)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G, H, I, J> Not for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B, C, D, E, F, G, H, I, J, K> Not for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.