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

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

This is supported on crate feature cmp only.

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 <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.

R: Is the type that implements ConstCmpMarker

Implementations

impl<T> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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> IsAConstCmpMarker<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: ?Sized> IsAConstCmpMarker<R::Kind, R::This, R> where
R: ?Sized + ConstCmpMarker,

pub const NEW: Self

Constructs an IsAConstCmpMarker

impl<K, T: ?Sized, R: ?Sized> IsAConstCmpMarker<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<U, T: ?Sized, R: ?Sized> IsAConstCmpMarker<IsArrayKind<U>, T, R>

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

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

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

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

An identity function, just takes reference and returns it.

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

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

Wraps reference in a CmpWrapper.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU8, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI8, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU16, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI16, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU32, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI32, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU64, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI64, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroU128, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroI128, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroUsize, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, NonZeroIsize, T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> IsAConstCmpMarker<IsStdKind, Ordering, T>

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

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

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

impl<T, T> IsAConstCmpMarker<IsStdKind, PhantomData<T>, T>

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

impl<T> IsAConstCmpMarker<IsStdKind, PhantomPinned, T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b, T> IsAConstCmpMarker<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> IsAConstCmpMarker<IsStdKind, Option<&'a [&'b [u8]]>, T>

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

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

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

impl<'a, T> IsAConstCmpMarker<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 IsAConstCmpMarker<K, T, R>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

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

Auto Trait Implementations

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

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>

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

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

pub fn from(t: T) -> T

Performs the conversion.

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

pub fn into(self) -> U

Performs the conversion.

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

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

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

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>

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.

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

Performs the conversion.