Crate manyfmt 

Adapters with which you can easily create more varieties of formatting than the std::fmt traits (fmt::Display, fmt::Debug, fmt::Binary, fmt::Pointer, etc.) offer, without having to write any more boilerplate than absolutely necessary. You can also easily pass additional data down through the formatting recursion.

To create a new format, declare a struct (struct MyFormat;) and implement Fmt<MyFormat> for the type you want to be able to format. Then call Refmt::refmt() to apply the format as a wrapper type around your data.

Example

The following code implements a minimal, non-validating TOML emitter. This demonstrates how manyfmt can be used to produce complex formatting, that operates within the std::fmt system without allocating, without writing a new by-reference wrapper type for each case.

use std::collections::BTreeMap;
use std::fmt;

use manyfmt::{Fmt, Refmt};

struct TomlFile;
struct TomlTable;

impl<S: AsRef<str>, T: Fmt<TomlTable>> Fmt<TomlFile> for BTreeMap<S, T> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>, _: &TomlFile) -> fmt::Result {
        for (key, table) in self {
            writeln!(
                fmt,
                "[{key}]\n{table}",
                key = key.as_ref(),
                table = table.refmt(&TomlTable)
            )?;
        }
        Ok(())
    }
}

impl<S: AsRef<str>, T: fmt::Debug> Fmt<TomlTable> for BTreeMap<S, T> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>, _: &TomlTable) -> fmt::Result {
        for (key, value) in self {
            // A real implementation would use TOML-specific value formatting
            // rather than `Debug`, which promises nothing.
            writeln!(fmt, "{key} = {value:?}", key = key.as_ref())?;
        }
        Ok(())
    }
}

let data = BTreeMap::from([
    ("package", BTreeMap::from([("name", "manyfmt"), ("edition", "2021")])),
    ("lib", BTreeMap::from([("name", "manyfmt")])),
]);

let text = data.refmt(&TomlFile).to_string();

assert_eq!(text,
r#"[lib]
name = "manyfmt"

[package]
edition = "2021"
name = "manyfmt"

"#);

Modules

formats

Simple predefined formats for use with refmt().

Structs

Wrapper

Wrapper type to replace the fmt::Display and fmt::Debug behavior of its contents with a Fmt implementation.

Traits

Fmt

Implement this trait to provide a new kind of formatting, F, for values of type Self.

Refmt

Extension trait providing the .refmt() convenience method.

Functions

refmt

Wrap value so that when formatted with fmt::Debug or fmt::Display, it uses the given Fmt custom format type instead.