Struct dbg_pls::Formatter

#[repr(transparent)]
pub struct Formatter<'a> { /* private fields */ }

Tool for formatting, used within DebugPls implementations

Implementations

impl<'a> Formatter<'a>

pub fn write_expr(self, expr: impl Into<Expr>)

Writes a wrap expression into the formatter. This is typically reserved for more advanced uses

pub fn debug_struct(self, name: &str) -> DebugStruct<'a>

Creates a DebugStruct builder designed to assist with creation of DebugPls implementations for structs.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};

struct Foo {
    bar: i32,
    baz: String,
}

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter) {
        f.debug_struct("Foo")
            .field("bar", &self.bar)
            .field("baz", &self.baz)
            .finish()
    }
}
let value = Foo {
    bar: 10,
    baz: "Hello World".to_string(),
};
assert_eq!(
    format!("{}", pretty(&value)),
    "Foo { bar: 10, baz: \"Hello World\" }",
);

pub fn debug_tuple(self) -> DebugTuple<'a>

Creates a DebugTuple builder designed to assist with creation of DebugPls implementations for tuples.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};

struct Foo(i32, String);

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter) {
        f.debug_tuple()
            .field(&self.0)
            .field(&self.1)
            .finish()
    }
}

let value = Foo(10, "Hello".to_string());
assert_eq!(format!("{}", pretty(&value)), "(10, \"Hello\")");

pub fn debug_tuple_struct(self, name: &str) -> DebugTupleStruct<'a>

Creates a DebugTupleStruct builder designed to assist with creation of DebugPls implementations for tuple structs.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};

struct Foo(i32, String);

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter) {
        f.debug_tuple_struct("Foo")
            .field(&self.0)
            .field(&self.1)
            .finish()
    }
}

let value = Foo(10, "Hello".to_string());
assert_eq!(format!("{}", pretty(&value)), "Foo(10, \"Hello\")");

pub fn debug_list(self) -> DebugList<'a>

Creates a DebugList builder designed to assist with creation of DebugPls implementations for list-like structures.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};

struct Foo(Vec<i32>);

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter<'_>) {
        f.debug_list().entries(&self.0).finish()
    }
}

let value = Foo(vec![10, 11]);
assert_eq!(format!("{}", pretty(&value)), "[10, 11]");

pub fn debug_map(self) -> DebugMap<'a>

Creates a DebugMap builder designed to assist with creation of DebugPls implementations for maps.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};
use std::collections::BTreeMap;

struct Foo(BTreeMap<String, i32>);

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter) {
        f.debug_map().entries(&self.0).finish()
    }
}
let mut value = Foo(BTreeMap::from([
    ("Hello".to_string(), 5),
    ("World".to_string(), 10),
]));
assert_eq!(
    format!("{}", pretty(&value)),
"{
    [\"Hello\"] = 5;
    [\"World\"] = 10;
}",
);

pub fn debug_set(self) -> DebugSet<'a>

Creates a DebugSet builder designed to assist with creation of DebugPls implementations for sets.

Examples

use dbg_pls::{pretty, DebugPls, Formatter};
use std::collections::BTreeSet;

struct Foo(BTreeSet<String>);

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter) {
        f.debug_set().entries(&self.0).finish()
    }
}
let mut value = Foo(BTreeSet::from([
    "Hello".to_string(),
    "World".to_string(),
]));
assert_eq!(
    format!("{}", pretty(&value)),
"{
    \"Hello\";
    \"World\"
}",
);

pub fn debug_ident(self, name: &str)

Writes an identifier into the formatter. Useful for unit structs/variants

Examples

use dbg_pls::{pretty, DebugPls, Formatter};

struct Foo;

impl DebugPls for Foo {
    fn fmt(&self, f: Formatter<'_>) {
        f.debug_ident("Foo");
    }
}

assert_eq!(format!("{}", pretty(&Foo)), "Foo");