Trait TypeEq

pub trait TypeEq {
    // Required method
    fn type_eq(&self, other: &Self) -> bool;
}

Available on crate feature __common only.

Derive with #[derive(TypeEq)].

Required Methods

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

Note: This method should return true for non-type values.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl TypeEq for bool

fn type_eq(&self, other: &bool) -> bool

impl TypeEq for char

fn type_eq(&self, other: &char) -> bool

impl TypeEq for f32

fn type_eq(&self, other: &f32) -> bool

impl TypeEq for f64

fn type_eq(&self, other: &f64) -> bool

impl TypeEq for i8

fn type_eq(&self, other: &i8) -> bool

impl TypeEq for i16

fn type_eq(&self, other: &i16) -> bool

impl TypeEq for i32

fn type_eq(&self, other: &i32) -> bool

impl TypeEq for i64

fn type_eq(&self, other: &i64) -> bool

impl TypeEq for i128

fn type_eq(&self, other: &i128) -> bool

impl TypeEq for isize

fn type_eq(&self, other: &isize) -> bool

impl TypeEq for str

fn type_eq(&self, other: &str) -> bool

impl TypeEq for u8

fn type_eq(&self, other: &u8) -> bool

impl TypeEq for u16

fn type_eq(&self, other: &u16) -> bool

impl TypeEq for u32

fn type_eq(&self, other: &u32) -> bool

impl TypeEq for u64

fn type_eq(&self, other: &u64) -> bool

impl TypeEq for u128

fn type_eq(&self, other: &u128) -> bool

impl TypeEq for usize

fn type_eq(&self, other: &usize) -> bool

impl TypeEq for String

fn type_eq(&self, other: &String) -> bool

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

where B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(B, A)) -> bool

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

where C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(C, B, A)) -> bool

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

where D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(J, I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(K, J, I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<N> TypeEq for &N

where N: TypeEq,

fn type_eq(&self, other: &&N) -> bool

impl<N> TypeEq for Box<N>

where N: TypeEq,

fn type_eq(&self, other: &Box<N>) -> bool

impl<N> TypeEq for Rc<N>

where N: TypeEq,

fn type_eq(&self, other: &Rc<N>) -> bool

impl<N> TypeEq for RefCell<N>

where N: TypeEq,

fn type_eq(&self, other: &RefCell<N>) -> bool

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

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

fn type_eq(&self, rhs: &(N, M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq(&self, rhs: &(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

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

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

fn type_eq( &self, rhs: &(P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

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

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

fn type_eq( &self, rhs: &(Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

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

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

fn type_eq( &self, rhs: &(R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

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

where S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<T> TypeEq for Option<T>

where T: TypeEq,

fn type_eq(&self, other: &Option<T>) -> bool

impl<T> TypeEq for Vec<T>

where T: TypeEq,

fn type_eq(&self, other: &Vec<T>) -> bool

impl<T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where Y: TypeEq, X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

impl<Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where Z: TypeEq, Y: TypeEq, X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), ) -> bool

Implementors

impl TypeEq for BigInt

impl TypeEq for BytePos

impl TypeEq for Span

impl<N> TypeEq for Arc<N>

where N: TypeEq,