Struct const_cmp::polymorphism::IsAConstCmpMarker[−][src]

pub struct IsAConstCmpMarker<K, T: ?Sized, R: ?Sized>(_);

Hack used to automatically wrap standard library types inside CmpWrapper, while leaving user defined types unwrapped.

Type parameters

K is <R as ConstCmpMarker>::Kind The kind of type that T is, a slice, other std types, non-std types.

T is <R as ConstCmpMarker>::This, the R type after removing all layers of references.

Coerce Method

The coerce method is what does the conversion from a &T depending on the K type parameter:

IsArrayKind: the reference is coerced to a slice, and wrapped in a CmpWrapper.
IsStdKind: the referenced value is copied, and wrapped in a CmpWrapper.
IsNotStdKind: the reference is simply returned as a &T.

Implementations

`impl<T> IsAConstCmpMarker<IsStdKind, i8, T>`[src]

`pub const fn coerce(self, reference: &i8) -> CmpWrapper<i8>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, u8, T>`[src]

`pub const fn coerce(self, reference: &u8) -> CmpWrapper<u8>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, i16, T>`[src]

`pub const fn coerce(self, reference: &i16) -> CmpWrapper<i16>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, u16, T>`[src]

`pub const fn coerce(self, reference: &u16) -> CmpWrapper<u16>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, i32, T>`[src]

`pub const fn coerce(self, reference: &i32) -> CmpWrapper<i32>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, u32, T>`[src]

`pub const fn coerce(self, reference: &u32) -> CmpWrapper<u32>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, i64, T>`[src]

`pub const fn coerce(self, reference: &i64) -> CmpWrapper<i64>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, u64, T>`[src]

`pub const fn coerce(self, reference: &u64) -> CmpWrapper<u64>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, i128, T>`[src]

`pub const fn coerce(self, reference: &i128) -> CmpWrapper<i128>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, u128, T>`[src]

`pub const fn coerce(self, reference: &u128) -> CmpWrapper<u128>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, isize, T>`[src]

`pub const fn coerce(self, reference: &isize) -> CmpWrapper<isize>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, usize, T>`[src]

`pub const fn coerce(self, reference: &usize) -> CmpWrapper<usize>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, bool, T>`[src]

`pub const fn coerce(self, reference: &bool) -> CmpWrapper<bool>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<T> IsAConstCmpMarker<IsStdKind, char, T>`[src]

`pub const fn coerce(self, reference: &char) -> CmpWrapper<char>`[src]

Copies the value from reference, and wraps it in a CmpWrapper

`impl<R: ?Sized> IsAConstCmpMarker<R::Kind, R::This, R> where R: ConstCmpMarker,` [src]

`pub const NEW: Self`[src]

Constructs an IsAConstCmpMarker

`impl<K, T: ?Sized, R: ?Sized> IsAConstCmpMarker<K, T, R>`[src]

`pub const fn infer_type(self, _: &R) -> Self`[src]

Infers the type parameters by taking a reference to R .

The K and T type parameters are determined by R in the NEW associated constant.

`pub const fn unreference(self, r: &T) -> &T`[src]

Removes layers of references by coercing the argument.

`impl<U, T: ?Sized, R: ?Sized> IsAConstCmpMarker<IsArrayKind<U>, T, R>`[src]

`pub const fn coerce(self, slice: &[U]) -> CmpWrapper<&[U]>`[src]

Coerces an array to a slice, then wraps the slice in a CmpWrapper

`impl<T: ?Sized, R: ?Sized> IsAConstCmpMarker<IsNotStdKind, T, R>`[src]

`pub const fn coerce(self, reference: &T) -> &T`[src]

An identity function, just takes reference and returns it.

`impl<R: ?Sized> IsAConstCmpMarker<IsStdKind, str, R>`[src]

`pub const fn coerce(self, reference: &str) -> CmpWrapper<&str>`[src]

Wraps reference in a CmpWrapper.

`impl<T> IsAConstCmpMarker<IsStdKind, Option<u8>, T>`[src]

`pub const fn coerce(self, reference: &Option<u8>) -> CmpWrapper<Option<u8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<i8>, T>`[src]

`pub const fn coerce(self, reference: &Option<i8>) -> CmpWrapper<Option<i8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<u16>, T>`[src]

`pub const fn coerce(self, reference: &Option<u16>) -> CmpWrapper<Option<u16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<i16>, T>`[src]

`pub const fn coerce(self, reference: &Option<i16>) -> CmpWrapper<Option<i16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<u32>, T>`[src]

`pub const fn coerce(self, reference: &Option<u32>) -> CmpWrapper<Option<u32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<i32>, T>`[src]

`pub const fn coerce(self, reference: &Option<i32>) -> CmpWrapper<Option<i32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<u64>, T>`[src]

`pub const fn coerce(self, reference: &Option<u64>) -> CmpWrapper<Option<u64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<i64>, T>`[src]

`pub const fn coerce(self, reference: &Option<i64>) -> CmpWrapper<Option<i64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<u128>, T>`[src]

`pub const fn coerce(self, reference: &Option<u128>) -> CmpWrapper<Option<u128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<i128>, T>`[src]

`pub const fn coerce(self, reference: &Option<i128>) -> CmpWrapper<Option<i128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<usize>, T>`[src]

`pub const fn coerce( self, reference: &Option<usize> ) -> CmpWrapper<Option<usize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<isize>, T>`[src]

`pub const fn coerce( self, reference: &Option<isize> ) -> CmpWrapper<Option<isize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<bool>, T>`[src]

`pub const fn coerce(self, reference: &Option<bool>) -> CmpWrapper<Option<bool>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<char>, T>`[src]

`pub const fn coerce(self, reference: &Option<char>) -> CmpWrapper<Option<char>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<u8>, T>`[src]

`pub const fn coerce(self, range: &Range<u8>) -> CmpWrapper<Range<u8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<u16>, T>`[src]

`pub const fn coerce(self, range: &Range<u16>) -> CmpWrapper<Range<u16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<u32>, T>`[src]

`pub const fn coerce(self, range: &Range<u32>) -> CmpWrapper<Range<u32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<u64>, T>`[src]

`pub const fn coerce(self, range: &Range<u64>) -> CmpWrapper<Range<u64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<u128>, T>`[src]

`pub const fn coerce(self, range: &Range<u128>) -> CmpWrapper<Range<u128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<usize>, T>`[src]

`pub const fn coerce(self, range: &Range<usize>) -> CmpWrapper<Range<usize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Range<char>, T>`[src]

`pub const fn coerce(self, range: &Range<char>) -> CmpWrapper<Range<char>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<u8>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<u8> ) -> CmpWrapper<RangeInclusive<u8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<u16>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<u16> ) -> CmpWrapper<RangeInclusive<u16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<u32>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<u32> ) -> CmpWrapper<RangeInclusive<u32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<u64>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<u64> ) -> CmpWrapper<RangeInclusive<u64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<u128>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<u128> ) -> CmpWrapper<RangeInclusive<u128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<usize>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<usize> ) -> CmpWrapper<RangeInclusive<usize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, RangeInclusive<char>, T>`[src]

`pub const fn coerce( self, range: &RangeInclusive<char> ) -> CmpWrapper<RangeInclusive<char>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU8, T>`[src]

`pub const fn coerce(self, reference: &NonZeroU8) -> CmpWrapper<NonZeroU8>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI8, T>`[src]

`pub const fn coerce(self, reference: &NonZeroI8) -> CmpWrapper<NonZeroI8>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU16, T>`[src]

`pub const fn coerce(self, reference: &NonZeroU16) -> CmpWrapper<NonZeroU16>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI16, T>`[src]

`pub const fn coerce(self, reference: &NonZeroI16) -> CmpWrapper<NonZeroI16>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU32, T>`[src]

`pub const fn coerce(self, reference: &NonZeroU32) -> CmpWrapper<NonZeroU32>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI32, T>`[src]

`pub const fn coerce(self, reference: &NonZeroI32) -> CmpWrapper<NonZeroI32>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU64, T>`[src]

`pub const fn coerce(self, reference: &NonZeroU64) -> CmpWrapper<NonZeroU64>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI64, T>`[src]

`pub const fn coerce(self, reference: &NonZeroI64) -> CmpWrapper<NonZeroI64>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU128, T>`[src]

`pub const fn coerce(self, reference: &NonZeroU128) -> CmpWrapper<NonZeroU128>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI128, T>`[src]

`pub const fn coerce(self, reference: &NonZeroI128) -> CmpWrapper<NonZeroI128>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroUsize, T>`[src]

`pub const fn coerce(self, reference: &NonZeroUsize) -> CmpWrapper<NonZeroUsize>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, NonZeroIsize, T>`[src]

`pub const fn coerce(self, reference: &NonZeroIsize) -> CmpWrapper<NonZeroIsize>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroU8>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroU8> ) -> CmpWrapper<Option<NonZeroU8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroI8>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroI8> ) -> CmpWrapper<Option<NonZeroI8>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroU16>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroU16> ) -> CmpWrapper<Option<NonZeroU16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroI16>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroI16> ) -> CmpWrapper<Option<NonZeroI16>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroU32>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroU32> ) -> CmpWrapper<Option<NonZeroU32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroI32>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroI32> ) -> CmpWrapper<Option<NonZeroI32>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroU64>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroU64> ) -> CmpWrapper<Option<NonZeroU64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroI64>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroI64> ) -> CmpWrapper<Option<NonZeroI64>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroU128>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroU128> ) -> CmpWrapper<Option<NonZeroU128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroI128>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroI128> ) -> CmpWrapper<Option<NonZeroI128>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroUsize>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroUsize> ) -> CmpWrapper<Option<NonZeroUsize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<NonZeroIsize>, T>`[src]

`pub const fn coerce( self, reference: &Option<NonZeroIsize> ) -> CmpWrapper<Option<NonZeroIsize>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Ordering, T>`[src]

`pub const fn coerce(self, reference: &Ordering) -> CmpWrapper<Ordering>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, Option<Ordering>, T>`[src]

`pub const fn coerce( self, reference: &Option<Ordering> ) -> CmpWrapper<Option<Ordering>>`[src]

`impl<T, T> IsAConstCmpMarker<IsStdKind, PhantomData<T>, T>`[src]

`pub const fn coerce( self, reference: &PhantomData<T> ) -> CmpWrapper<PhantomData<T>>`[src]

`impl<T> IsAConstCmpMarker<IsStdKind, PhantomPinned, T>`[src]

`pub const fn coerce( self, reference: &PhantomPinned ) -> CmpWrapper<PhantomPinned>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [u8]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [u8]> ) -> CmpWrapper<Option<&'a [u8]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [u16]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [u16]> ) -> CmpWrapper<Option<&'a [u16]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [u32]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [u32]> ) -> CmpWrapper<Option<&'a [u32]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [u64]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [u64]> ) -> CmpWrapper<Option<&'a [u64]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [u128]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [u128]> ) -> CmpWrapper<Option<&'a [u128]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [i8]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [i8]> ) -> CmpWrapper<Option<&'a [i8]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [i16]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [i16]> ) -> CmpWrapper<Option<&'a [i16]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [i32]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [i32]> ) -> CmpWrapper<Option<&'a [i32]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [i64]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [i64]> ) -> CmpWrapper<Option<&'a [i64]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [i128]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [i128]> ) -> CmpWrapper<Option<&'a [i128]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [bool]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [bool]> ) -> CmpWrapper<Option<&'a [bool]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a [char]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [char]> ) -> CmpWrapper<Option<&'a [char]>>`[src]

`impl<'a, 'b, T> IsAConstCmpMarker<IsStdKind, Option<&'a [&'b str]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [&'b str]> ) -> CmpWrapper<Option<&'a [&'b str]>>`[src]

`impl<'a, 'b, T> IsAConstCmpMarker<IsStdKind, Option<&'a [&'b [u8]]>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a [&'b [u8]]> ) -> CmpWrapper<Option<&'a [&'b [u8]]>>`[src]

`impl<'a, T> IsAConstCmpMarker<IsStdKind, Option<&'a str>, T>`[src]

`pub const fn coerce( self, reference: &Option<&'a str> ) -> CmpWrapper<Option<&'a str>>`[src]

Trait Implementations

`impl<K, T: ?Sized, R: ?Sized> Clone for IsAConstCmpMarker<K, T, R>`[src]

`fn clone(&self) -> Self`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<K, T: ?Sized, R: ?Sized> Copy for IsAConstCmpMarker<K, T, R>`[src]

Auto Trait Implementations

`impl<K, T: ?Sized, R: ?Sized> Send for IsAConstCmpMarker<K, T, R>`

`impl<K, T: ?Sized, R: ?Sized> Sync for IsAConstCmpMarker<K, T, R>`

`impl<K, T: ?Sized, R: ?Sized> Unpin for IsAConstCmpMarker<K, T, R>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]