12. Formatting

formatting.md

12. Formatting

format! and print!

fn main() {
    let s = format!("{}", 12u32);            // Integers
    println!("{}", s);                       // Strings
    println!("{}", 123.456f64);              // Floats
    println!("{}", "abc");                   // String slices
    println!("{}", &s);                      // String references
    print!("{}", true);                      // Bools
    println!("{}", false);                   //
    eprintln!("{}", "An error");             // to stderr
}

What to format?

fn main() {
    let s = "abc".to_string();
    let t = 123456789u64;
    println!("{} {}", s, t);
    println!("{1} {0}", s, t);
    println!("{s} {}", t);
    println!("{} {u}", t, u = s);
}

Formatting width, precision and alignment

fn main() {
    let s = "abc".to_string();
    let f = 123.456789f64;
    println!("{}", f);
    println!("{:20}", f);
    println!("{:>20}", f);
    println!("{:<20}", f);
    println!("{:^20}", f);
    println!("{:20}", s);
    println!("{:>20}", s);
    println!("{:<20}", s);
    println!("{:^20}", s);
    println!("{:20.4}", f);
    println!("{:<20.4}", f);
}

Fill and Sign

fn main() {
    let f = 123.456789f64;
    let i = 123456789u64;
    println!("{:*>20}", f);               // Fill with stars
    println!("{:*>+20}", f);              // Always print the sign
    println!("{:*>#20x}", i);             // Alternative form
    println!("{:#?}", vec![17, 18, 19]);  // Alternative form
}

Formatting traits

fn main() {
    let s = "abc".to_string();
    let f = 123.456789f64;
    let i = 987654321u64;
    println!("{}", i);
    println!("{:b}", i);     // binary
    println!("{:20o}", i);   // octal
    println!("{:20x}", i);   // hex
    println!("{:20X}", i);   // Hex (capitalized)
    println!("{:20e}", f);   // scientific
    println!("{:20E}", f);   // scientific (capitalized)
    println!("{:p}", &s);    // pointer
}

Debug Formatting

#[derive(Debug)]
struct Pos {
    x : f64,
    y : f64,
}

fn main() {
    let s = "abc".to_string();
    let f = 123.456789f64;
    let i = 987654321u64;
    let p = Pos{ x: 17.1, y: -3.2 };
    println!("{:?}", s);
    println!("{:?}", f);
    println!("{:?}", i);
    println!("{:?}", p);
    println!("{:?}", vec![1u32, 2u32, 3u32]);
    println!("{} {}", p.x, p.y);
}

Putting it all together

fn main() {
    let f = 123.456789f64;
    let i = 987654321u64;
    let s = "abc".to_string();
    eprintln!("}} {f:-^+20.4} {{");    // format f, fill with -, with sign
    println!("}} {v:*^#30x} {{", v=i); // format i, fill with *, 0x prefix
    println!("}} {0:?>20p} {{", &s);   // format &s, fill with ?, as pointer
    println!("}} {:width$.4} {{", f, width = 30);  // runtime specified width
}

References:

• Rust documentation of format strings: https://doc.rust-lang.org/std/fmt/index.html
• Format macros: https://doc.rust-lang.org/std/macro.format.html
• Print macro: https://doc.rust-lang.org/std/macro.print.html
• Video: https://youtu.be/5KSUpOXlaio
• Overview: https://gist.github.com/max-itzpapalotl/18f7675a60f6f9603250367bcb63992e