Trait BitAnd 

pub trait BitAnd {
    type Value: BitSetLike;

    // Required method
    fn and(self) -> Self::Value;
}

Required Associated Types

type Value: BitSetLike

Required Methods

fn and(self) -> Self::Value

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike, L: BitSetLike, M: BitSetLike, N: BitSetLike, O: BitSetLike, P: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike, L: BitSetLike, M: BitSetLike, N: BitSetLike, O: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike, L: BitSetLike, M: BitSetLike, N: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike, L: BitSetLike, M: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K, L, M) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike, L: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K, L) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K, L) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike, K: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J, K) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J, K) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike, J: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I, J) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I, J) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike, I: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H, I) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H, I) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike, H: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G, H) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G, H) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike, G: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F, G) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F, G) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike, F: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E, F) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E, F) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike, E: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D, E) as Split>::Left as BitAnd>::Value, <<(A, B, C, D, E) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike, D: BitSetLike,

type Value = BitSetAnd<<<(A, B, C, D) as Split>::Left as BitAnd>::Value, <<(A, B, C, D) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike, C: BitSetLike,

type Value = BitSetAnd<<<(A, B, C) as Split>::Left as BitAnd>::Value, <<(A, B, C) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

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

where A: BitSetLike, B: BitSetLike,

type Value = BitSetAnd<<<(A, B) as Split>::Left as BitAnd>::Value, <<(A, B) as Split>::Right as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A> BitAnd for (A,)

where A: BitSetLike,

type Value = A

fn and(self) -> Self::Value

Implementors