const_format::marker_traits

Struct IsAFormatMarker

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

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, Ordering, 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, R> Freeze for IsAFormatMarker<K, T, R>
where T: ?Sized, R: ?Sized,

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

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

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

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

impl<K, T, R> UnwindSafe for IsAFormatMarker<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,

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

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

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes