Trait const_format::marker_traits::FormatMarker

source · [−]
pub trait FormatMarker {
    type Kind;
    type This: ?Sized;
}
Available on crate feature fmt only.
Expand description

Marker trait for types that implement the const formatting methods.

Debug formatting can be derived using the ConstDebug derive macro.

Implementors

Types that implement this trait are also expected to implement at least one of these inherent methods:

ⓘ
// use const_format::{Error, Format};

const fn const_debug_fmt(&self, &mut Formatter<'_>) -> Result<(), Error>

const fn const_display_fmt(&self, &mut Formatter<'_>) -> Result<(), Error>

Coercions

The Kind and This associated types are used in the IsAFormatMarker marker type to automatically wrap types in PWrapper if they’re from the standard library, otherwise leaving them unwrapped.

Examples

Display formatting

This example demonstrates how you can implement display formatting, without using the impl_fmt macro.

#![feature(const_mut_refs)]

use const_format::{
    marker_traits::{FormatMarker, IsNotStdKind},
    Error, Formatter, StrWriter,
    formatc, writec,
};

use std::cmp::Ordering;


struct Compared(u32, Ordering, u32);

// This is what the `impl_fmt` macro implements implicitly for all non-std types
impl FormatMarker for Compared {
    type Kind = IsNotStdKind;
    type This = Self;
}

impl Compared {
    pub const fn const_display_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let op = match self.1 {
            Ordering::Less => "<",
            Ordering::Equal => "==",
            Ordering::Greater => ">",
        };
        writec!(f, "{} {} {}", self.0, op, self.2)
    }
}

const S_0: &str = formatc!("{}", Compared(0, Ordering::Less, 1));
const S_1: &str = formatc!("{}", Compared(1, Ordering::Equal, 1));
const S_2: &str = formatc!("{}", Compared(2, Ordering::Greater, 1));

assert_eq!(S_0, "0 < 1");
assert_eq!(S_1, "1 == 1");
assert_eq!(S_2, "2 > 1");

Debug formatting

For examples of using the ConstDebug derive macro, look here.

These are examples of implementing debug formatting using the impl_fmt macro for:

Required Associated Types

What kind of type this is, this can be one of:

The type after dereferencing, implemented as type This = Self; for all non-reference types

Implementations on Foreign Types

Implementors