Struct const_format::marker_traits::IsAFormatMarker

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

Available on crate feature fmt only.

Expand description

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

Type parameters

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

T is <R as FormatMarker>::This: The R type after removing all layers of references.

R: a type that implements FormatMarker.

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 PWrapper.
IsStdKind: the referenced value is copied, and wrapped in a PWrapper.
IsNotStdKind: the reference is simply returned as a &T.

Implementations§

impl<R> IsAFormatMarker<R::Kind, R::This, R>where R: ?Sized + FormatMarker,

pub const NEW: Self = _

Constructs an IsAFormatMarker

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

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

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

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

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

An identity function, just takes reference and returns it.

impl<T> IsAFormatMarker<IsStdKind, i8, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, u8, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, i16, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, u16, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, i32, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, u32, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, i64, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, u64, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, i128, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, u128, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, isize, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, usize, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, bool, T>

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

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

impl<T> IsAFormatMarker<IsStdKind, char, T>

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

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

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

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

Wraps reference in a PWrapper.

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

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

impl<T> IsAFormatMarker<IsStdKind, RangeFrom<usize>, T>

pub const fn coerce( self, range: &RangeFrom<usize> ) -> PWrapper<RangeFrom<usize>>

impl<T> IsAFormatMarker<IsStdKind, RangeTo<usize>, T>

pub const fn coerce(self, range: &RangeTo<usize>) -> PWrapper<RangeTo<usize>>

impl<T> IsAFormatMarker<IsStdKind, RangeToInclusive<usize>, T>

pub const fn coerce( self, range: &RangeToInclusive<usize> ) -> PWrapper<RangeToInclusive<usize>>

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

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

impl<T> IsAFormatMarker<IsStdKind, RangeFull, T>

pub const fn coerce(self, _: &RangeFull) -> PWrapper<RangeFull>

impl<T, T> IsAFormatMarker<IsStdKind, Option<NonNull<T>>, T>

pub const fn coerce( self, reference: &Option<NonNull<T>> ) -> PWrapper<Option<NonNull<T>>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroU8, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroI8, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroU16, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroI16, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroU32, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroI32, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroU64, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroI64, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroU128, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroI128, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroUsize, T>

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

impl<T> IsAFormatMarker<IsStdKind, NonZeroIsize, T>

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

impl<T, T> IsAFormatMarker<IsStdKind, *mut T, T>

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

impl<T, T> IsAFormatMarker<IsStdKind, *const T, T>

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

impl<T, T> IsAFormatMarker<IsStdKind, NonNull<T>, T>

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

impl<T: ?Sized, T> IsAFormatMarker<IsStdKind, PhantomData<T>, T>

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

impl<T> IsAFormatMarker<IsStdKind, PhantomPinned, T>

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

impl<T> IsAFormatMarker<IsStdKind, (), T>

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

impl<T> IsAFormatMarker<IsStdKind, AtomicOrdering, T>

pub const fn coerce( self, reference: &AtomicOrdering ) -> PWrapper<AtomicOrdering>

impl<T> IsAFormatMarker<IsStdKind, Ordering, T>

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

Trait Implementations§

impl<K, T: ?Sized, R: ?Sized> Clone for IsAFormatMarker<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 IsAFormatMarker<K, T, R>

Auto Trait Implementations§

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

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

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

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

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

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Twhere 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 Twhere 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 Twhere 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.