Trait goggles::join::BitAnd

pub trait BitAnd {
    type Value: BitSetLike;
    fn and(self) -> Self::Value;
}

Associated Types

type Value: BitSetLike

Loading content...

Required methods

fn and(self) -> Self::Value

Loading content...

Implementations on Foreign Types

impl<A> BitAnd for (A,) where
    A: BitSetLike, 

type Value = A

fn and(self) -> Self::Value

impl<A, B> BitAnd for (A, B) where
    A: BitSetLike,
    B: BitSetLike, 

type Value = BitSetAnd<A, <(B,) 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 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 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 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 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 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 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 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 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 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 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 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 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 BitAnd>::Value>

fn and(self) -> Self::Value

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 BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) 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,
    Q: BitSetLike, 

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

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) 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,
    Q: BitSetLike,
    R: BitSetLike, 

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

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike, 

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

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike, 

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

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike,
    V: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike,
    V: BitSetLike,
    W: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike,
    V: BitSetLike,
    W: BitSetLike,
    X: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike,
    V: BitSetLike,
    W: BitSetLike,
    X: BitSetLike,
    Y: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as BitAnd>::Value>

fn and(self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> BitAnd for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) 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,
    Q: BitSetLike,
    R: BitSetLike,
    S: BitSetLike,
    T: BitSetLike,
    U: BitSetLike,
    V: BitSetLike,
    W: BitSetLike,
    X: BitSetLike,
    Y: BitSetLike,
    Z: BitSetLike, 

type Value = BitSetAnd<A, <(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as BitAnd>::Value>

fn and(self) -> Self::Value

Loading content...

Implementors

Loading content...