Struct konst::cmp::IsAConstCmp

pub struct IsAConstCmp<K, T: ?Sized, R: ?Sized>(/* private fields */);

Expand description

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

This can be constructed with he NEW associated constant

§Type parameters

K is <T as ConstCmp>::Kind The kind of type that T is: either IsStdKind or IsNotStdKind.

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

R: Is a type that implements ConstCmp

Implementations§

impl<T> IsAConstCmp<IsStdKind, i8, T>

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

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

impl<T> IsAConstCmp<IsStdKind, u8, T>

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

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

impl<T> IsAConstCmp<IsStdKind, i16, T>

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

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

impl<T> IsAConstCmp<IsStdKind, u16, T>

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

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

impl<T> IsAConstCmp<IsStdKind, i32, T>

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

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

impl<T> IsAConstCmp<IsStdKind, u32, T>

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

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

impl<T> IsAConstCmp<IsStdKind, i64, T>

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

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

impl<T> IsAConstCmp<IsStdKind, u64, T>

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

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

impl<T> IsAConstCmp<IsStdKind, i128, T>

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

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

impl<T> IsAConstCmp<IsStdKind, u128, T>

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

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

impl<T> IsAConstCmp<IsStdKind, isize, T>

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

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

impl<T> IsAConstCmp<IsStdKind, usize, T>

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

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

impl<T> IsAConstCmp<IsStdKind, bool, T>

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

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

impl<T> IsAConstCmp<IsStdKind, char, T>

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

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

impl<R, T> IsAConstCmp<T::Kind, T, R>
where R: ?Sized + ConstCmpUnref<This = T>, T: ?Sized + ConstCmp,

pub const NEW: Self = _

Constructs an IsAConstCmp

impl<K, T: ?Sized, R: ?Sized> IsAConstCmp<K, T, R>

pub const fn infer_type(self, _: &R) -> Self

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

Removes layers of references by coercing the argument.

impl<T: ?Sized, R: ?Sized> IsAConstCmp<IsNotStdKind, T, R>

pub const fn coerce(self, reference: &T) -> &T

An identity function, just takes reference and returns it.

impl<R: ?Sized> IsAConstCmp<IsStdKind, str, R>

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

Wraps reference in a CmpWrapper.

impl<T, R: ?Sized> IsAConstCmp<IsStdKind, [T], R>

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

Wraps reference in a CmpWrapper.

impl<T, R, const N: usize> IsAConstCmp<IsStdKind, [T; N], R>

pub const fn coerce(self, reference: &[T; N]) -> CmpWrapper<&[T]>

Wraps reference in a CmpWrapper.

impl<T> IsAConstCmp<IsStdKind, Option<u8>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<i8>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<u16>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<i16>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<u32>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<i32>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<u64>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<i64>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<u128>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<i128>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<usize>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<isize>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<bool>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<char>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<u8>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<u16>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<u32>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<u64>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<u128>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<usize>, T>

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

impl<T> IsAConstCmp<IsStdKind, Range<char>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<u8>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<u16>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<u32>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<u64>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<u128>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<usize>, T>

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

impl<T> IsAConstCmp<IsStdKind, RangeInclusive<char>, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroU8, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroI8, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroU16, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroI16, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroU32, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroI32, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroU64, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroI64, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroU128, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroI128, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroUsize, T>

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

impl<T> IsAConstCmp<IsStdKind, NonZeroIsize, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroU8>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroI8>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroU16>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroI16>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroU32>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroI32>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroU64>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroI64>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroU128>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroI128>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroUsize>, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<NonZeroIsize>, T>

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

impl<T> IsAConstCmp<IsStdKind, Ordering, T>

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

impl<T> IsAConstCmp<IsStdKind, Option<Ordering>, T>

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

impl<T, T> IsAConstCmp<IsStdKind, PhantomData<T>, T>

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

impl<T> IsAConstCmp<IsStdKind, PhantomPinned, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [u16]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [u32]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [u64]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [u128]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [usize]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [i8]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [i16]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [i32]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [i64]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [i128]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [isize]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [bool]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [char]>, T>

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

impl<'a, 'b, T> IsAConstCmp<IsStdKind, Option<&'a [&'b str]>, T>

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

impl<'a, 'b, T> IsAConstCmp<IsStdKind, Option<&'a [&'b [u8]]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a [u8]>, T>

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

impl<'a, T> IsAConstCmp<IsStdKind, Option<&'a str>, T>

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

Trait Implementations§

impl<K, T: ?Sized, R: ?Sized> Clone for IsAConstCmp<K, T, R>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<K, T: ?Sized, R: ?Sized> Copy for IsAConstCmp<K, T, R>

Auto Trait Implementations§

impl<K, T, R> Freeze for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

impl<K, T, R> RefUnwindSafe for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

impl<K, T, R> Send for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

impl<K, T, R> Sync for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

impl<K, T, R> Unpin for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

impl<K, T, R> UnwindSafe for IsAConstCmp<K, T, R>
where T: ?Sized, R: ?Sized,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dst. Read more

impl<T> CloneToUninit for T
where T: Copy,

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dst. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

const WITNESS: W = W::MAKE

A constant of the type witness

impl<T> Identity for T
where T: ?Sized,

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

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

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.