Rust Output and I/O Operations

Introduction to Output in Rust

Rust provides several ways to output data, from simple console printing to complex formatted output and file I/O. Understanding these mechanisms is crucial for debugging, user interaction, and data persistence. Rust's output system is built around macros and traits that provide flexibility, type safety, and performance.

1. Console Output Macros

Basic Printing Macros

fn main() {
// println! - prints with newline
println!("Hello, World!");
// print! - prints without newline
print!("Hello, ");
print!("World!");
// Output: Hello, World! (on same line)
// eprintln! - prints to stderr with newline (for errors)
eprintln!("Error: Something went wrong!");
// eprint! - prints to stderr without newline
eprint!("Processing... ");
eprint!("Done!");
}

Formatted Output with println! and print!

fn main() {
let name = "Alice";
let age = 30;
let height = 5.8;
// Basic formatting
println!("Name: {}, Age: {}, Height: {}", name, age, height);
// Positional arguments
println!("{0} is {1} years old. {0} loves Rust!", name, age);
// Named arguments
println!("{name} is {age} years old", name = "Bob", age = 25);
// Formatting numbers
println!("Decimal: {} Hex: {:X} Octal: {:o}", 255, 255, 255);
println!("Binary: {:b}", 42);
// Padding and alignment
println!("|{:5}|", 42);        // Right align, width 5: "|   42|"
println!("|{:<5}|", 42);       // Left align:  "|42   |"
println!("|{:^5}|", 42);       // Center:      "| 42  |"
println!("|{:*^5}|", 42);      // Center with * fill: "|**42*|"
// Precision for floats
let pi = 3.14159265359;
println!("Pi: {:.2}", pi);      // 2 decimal places: "3.14"
println!("Pi: {:.5}", pi);      // 5 decimal places: "3.14159"
// Debug formatting
let vec = vec![1, 2, 3];
println!("Debug: {:?}", vec);    // [1, 2, 3]
println!("Pretty: {:#?}", vec);  // Formatted with newlines
// Display vs Debug
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
let p = Point { x: 10, y: 20 };
println!("Debug: {:?}", p);      // Point { x: 10, y: 20 }
println!("Pretty: {:#?}", p);    // Point {
//     x: 10,
//     y: 20,
// }
}

2. Custom Display and Debug Formatting

Implementing Display Trait

use std::fmt;
struct Person {
name: String,
age: u32,
}
// Implement Display for custom formatting
impl fmt::Display for Person {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{} ({})", self.name, self.age)
}
}
// Custom Debug implementation
impl fmt::Debug for Person {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Person")
.field("name", &self.name)
.field("age", &self.age)
.finish()
}
}
fn main() {
let person = Person {
name: String::from("Alice"),
age: 30,
};
println!("Display: {}", person);      // Alice (30)
println!("Debug: {:?}", person);      // Person { name: "Alice", age: 30 }
}

Advanced Formatter Features

use std::fmt;
struct RGB {
r: u8,
g: u8,
b: u8,
}
impl fmt::Display for RGB {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// Handle width and alignment specifications
let hex = format!("#{:02X}{:02X}{:02X}", self.r, self.g, self.b);
if let Some(width) = f.width() {
match f.align() {
Some(fmt::Alignment::Left) => write!(f, "{:<width$}", hex, width = width),
Some(fmt::Alignment::Right) => write!(f, "{:>width$}", hex, width = width),
Some(fmt::Alignment::Center) => write!(f, "{:^width$}", hex, width = width),
None => write!(f, "{:width$}", hex, width = width),
}
} else {
write!(f, "{}", hex)
}
}
}
fn main() {
let color = RGB { r: 255, g: 128, b: 0 };
println!("{}", color);              // #FF8000
println!("{:10}", color);           // "#FF8000   " (right aligned)
println!("{:<10}", color);          // "#FF8000   " (left aligned)
println!("{:^10}", color);          // " #FF8000  " (centered)
}

3. String Formatting

format! Macro

fn main() {
// Basic string formatting
let name = "Alice";
let age = 30;
let message = format!("{} is {} years old", name, age);
println!("{}", message);
// Building complex strings
let parts = vec!["Hello", "world", "from", "Rust"];
let sentence = parts.join(" ");
println!("{}", sentence);
// Format with conditional logic
let numbers = vec![1, 2, 3, 4, 5];
let formatted = numbers.iter()
.map(|n| format!("{}", n))
.collect::<Vec<String>>()
.join(", ");
println!("Numbers: {}", formatted);
// Using format! for error messages
fn divide(a: f64, b: f64) -> Result<f64, String> {
if b == 0.0 {
Err(format!("Cannot divide {} by zero", a))
} else {
Ok(a / b)
}
}
match divide(10.0, 0.0) {
Ok(result) => println!("Result: {}", result),
Err(e) => println!("Error: {}", e),
}
}

String Builders and Performance

use std::fmt::Write;
fn main() {
// Efficient string building
let mut output = String::new();
for i in 0..10 {
writeln!(&mut output, "Line {}", i).unwrap();
}
println!("{}", output);
// Using write! macro
let mut buffer = String::new();
write!(&mut buffer, "Hello, ").unwrap();
write!(&mut buffer, "World!").unwrap();
write!(&mut buffer, " The answer is {}.", 42).unwrap();
println!("{}", buffer);
// Performance comparison: format! vs push_str
let mut result = String::new();
// Fast: pre-allocate capacity
let mut fast = String::with_capacity(1000);
for i in 0..100 {
fast.push_str(&format!("Item {}\n", i));
}
// Even faster: use write! macro
let mut faster = String::with_capacity(1000);
for i in 0..100 {
writeln!(&mut faster, "Item {}", i).unwrap();
}
}

4. File Output

Basic File Writing

use std::fs::File;
use std::io::prelude::*;
use std::io::BufWriter;
fn main() -> std::io::Result<()> {
// Simple file write
let mut file = File::create("output.txt")?;
file.write_all(b"Hello, World!\n")?;
file.write_all("Line 2\n".as_bytes())?;
// Using write! macro with files
let mut file = File::create("formatted.txt")?;
write!(&mut file, "Name: {}\nAge: {}\n", "Alice", 30)?;
// Buffered writing for better performance
let file = File::create("buffered.txt")?;
let mut writer = BufWriter::new(file);
for i in 0..1000 {
writeln!(writer, "Line {}", i)?;
}
writer.flush()?; // Ensure all data is written
// Appending to file
use std::fs::OpenOptions;
let mut file = OpenOptions::new()
.write(true)
.append(true)
.create(true)
.open("log.txt")?;
writeln!(file, "Log entry at {}", chrono::Local::now())?;
Ok(())
}

Writing Structured Data

use std::fs::File;
use std::io::{Write, BufWriter};
use serde::{Serialize, Deserialize};
use serde_json;
use csv;
// JSON output
#[derive(Serialize, Deserialize, Debug)]
struct User {
id: u32,
name: String,
email: String,
active: bool,
}
fn write_json() -> std::io::Result<()> {
let users = vec![
User {
id: 1,
name: "Alice".to_string(),
email: "[email protected]".to_string(),
active: true,
},
User {
id: 2,
name: "Bob".to_string(),
email: "[email protected]".to_string(),
active: false,
},
];
// Write pretty JSON
let file = File::create("users.json")?;
let writer = BufWriter::new(file);
serde_json::to_writer_pretty(writer, &users)?;
// Write compact JSON
let file = File::create("users.min.json")?;
let writer = BufWriter::new(file);
serde_json::to_writer(writer, &users)?;
Ok(())
}
// CSV output
fn write_csv() -> std::io::Result<()> {
let file = File::create("users.csv")?;
let mut writer = csv::Writer::from_writer(file);
writer.write_record(&["ID", "Name", "Email", "Active"])?;
writer.write_record(&["1", "Alice", "[email protected]", "true"])?;
writer.write_record(&["2", "Bob", "[email protected]", "false"])?;
writer.flush()?;
Ok(())
}
// Binary output
fn write_binary() -> std::io::Result<()> {
use std::io::Write;
let mut file = File::create("data.bin")?;
// Write different data types
let number: u32 = 42;
let float: f64 = 3.14159;
let bytes = &[1, 2, 3, 4, 5];
file.write_all(&number.to_le_bytes())?;  // Write as little-endian
file.write_all(&float.to_le_bytes())?;
file.write_all(bytes)?;
Ok(())
}
fn main() -> std::io::Result<()> {
write_json()?;
write_csv()?;
write_binary()?;
Ok(())
}

5. Advanced Output Formatting

Table Formatting

fn print_table() {
let data = vec![
("Alice", 30, "Engineer"),
("Bob", 25, "Designer"),
("Charlie", 35, "Manager"),
("Diana", 28, "Developer"),
];
// Calculate column widths
let name_width = data.iter().map(|(n, _, _)| n.len()).max().unwrap_or(4).max(4);
let age_width = 3; // "Age" width
let role_width = data.iter().map(|(_, _, r)| r.len()).max().unwrap_or(4).max(4);
// Print header
println!("┌─{:─^name_width$}─┬─{:─^age_width$}─┬─{:─^role_width$}─┐", "", "", "",
name_width = name_width + 2, age_width = age_width + 2, role_width = role_width + 2);
println!("│ {:^name_width$} │ {:^age_width$} │ {:^role_width$} │",
"Name", "Age", "Role",
name_width = name_width, age_width = age_width, role_width = role_width);
println!("├─{:─^name_width$}─┼─{:─^age_width$}─┼─{:─^role_width$}─┤", "", "", "",
name_width = name_width + 2, age_width = age_width + 2, role_width = role_width + 2);
// Print data rows
for (name, age, role) in data {
println!("│ {:name_width$} │ {:age_width$} │ {:role_width$} │",
name, age, role,
name_width = name_width, age_width = age_width, role_width = role_width);
}
// Print footer
println!("└─{:─^name_width$}─┴─{:─^age_width$}─┴─{:─^role_width$}─┘", "", "", "",
name_width = name_width + 2, age_width = age_width + 2, role_width = role_width + 2);
}
// Using external crate for tables
use prettytable::{Table, Row, Cell};
use prettytable::format;
fn print_table_pretty() {
let mut table = Table::new();
table.set_format(*format::consts::FORMAT_BOX_CHARS);
table.add_row(Row::new(vec![
Cell::new("Name"),
Cell::new("Age"),
Cell::new("Role"),
]));
table.add_row(Row::new(vec![
Cell::new("Alice"),
Cell::new("30"),
Cell::new("Engineer"),
]));
table.add_row(Row::new(vec![
Cell::new("Bob"),
Cell::new("25"),
Cell::new("Designer"),
]));
table.printstd();
}
fn main() {
println!("Custom table:");
print_table();
println!("\nPretty table:");
print_table_pretty();
}

Progress Indicators

use std::thread;
use std::time::Duration;
// Simple progress bar
fn simple_progress_bar() {
let total = 50;
print!("Progress: [");
for i in 0..total {
print!("=");
std::io::stdout().flush().unwrap();
thread::sleep(Duration::from_millis(50));
}
println!("] Done!");
}
// Animated spinner
fn spinner() {
let frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
let mut i = 0;
for _ in 0..100 {
print!("\rLoading... {}", frames[i]);
std::io::stdout().flush().unwrap();
thread::sleep(Duration::from_millis(50));
i = (i + 1) % frames.len();
}
println!("\rLoading... Done!     ");
}
// Using indicatif crate for better progress bars
use indicatif::{ProgressBar, ProgressStyle};
fn advanced_progress() {
let pb = ProgressBar::new(100);
pb.set_style(
ProgressStyle::default_bar()
.template("[{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} ({eta})")
.unwrap()
.progress_chars("#>-"),
);
for i in 0..100 {
// Do some work
thread::sleep(Duration::from_millis(20));
pb.inc(1);
}
pb.finish_with_message("Done!");
}
fn main() {
simple_progress_bar();
println!();
spinner();
println!();
advanced_progress();
}

6. Logging and Debug Output

Simple Logging

use std::fs::OpenOptions;
use std::io::Write;
use std::time::SystemTime;
enum LogLevel {
Info,
Warning,
Error,
}
impl std::fmt::Display for LogLevel {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
LogLevel::Info => write!(f, "INFO"),
LogLevel::Warning => write!(f, "WARNING"),
LogLevel::Error => write!(f, "ERROR"),
}
}
}
struct Logger {
file: Option<std::fs::File>,
}
impl Logger {
fn new(log_file: Option<&str>) -> std::io::Result<Self> {
let file = if let Some(path) = log_file {
Some(OpenOptions::new()
.create(true)
.append(true)
.open(path)?)
} else {
None
};
Ok(Logger { file })
}
fn log(&mut self, level: LogLevel, message: &str) -> std::io::Result<()> {
let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
let log_entry = format!("[{}] {}: {}\n", timestamp, level, message);
// Write to console
match level {
LogLevel::Error => eprint!("{}", log_entry),
_ => print!("{}", log_entry),
}
// Write to file if configured
if let Some(file) = &mut self.file {
file.write_all(log_entry.as_bytes())?;
}
Ok(())
}
}
fn main() -> std::io::Result<()> {
let mut logger = Logger::new(Some("app.log"))?;
logger.log(LogLevel::Info, "Application started")?;
logger.log(LogLevel::Warning, "Low disk space")?;
logger.log(LogLevel::Error, "Failed to connect to database")?;
Ok(())
}

Using the log crate

use log::{info, warn, error, debug, LevelFilter};
use env_logger;
fn init_logging() {
env_logger::Builder::new()
.filter(None, LevelFilter::Debug)
.format(|buf, record| {
use std::io::Write;
writeln!(
buf,
"[{} {}:{}] {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
record.file().unwrap_or("unknown"),
record.line().unwrap_or(0),
record.args()
)
})
.init();
}
fn main() {
init_logging();
info!("Application starting up");
debug!("Debug information: {:?}", vec![1, 2, 3]);
warn!("This is a warning");
error!("An error occurred");
// The output will be:
// [2024-01-01 12:34:56 src/main.rs:25] Application starting up
// [2024-01-01 12:34:56 src/main.rs:26] Debug information: [1, 2, 3]
// [2024-01-01 12:34:56 src/main.rs:27] This is a warning
// [2024-01-01 12:34:56 src/main.rs:28] An error occurred
}

7. Network Output

HTTP Requests and Responses

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
// Simple HTTP server
fn handle_client(mut stream: TcpStream) -> std::io::Result<()> {
let mut buffer = [0; 1024];
stream.read(&mut buffer)?;
let response = "HTTP/1.1 200 OK\r\n\
Content-Type: text/html\r\n\
\r\n\
<html><body><h1>Hello from Rust!</h1></body></html>";
stream.write_all(response.as_bytes())?;
stream.flush()?;
Ok(())
}
fn start_server() -> std::io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:8080")?;
println!("Server running on http://127.0.0.1:8080");
for stream in listener.incoming() {
match stream {
Ok(stream) => {
std::thread::spawn(|| {
if let Err(e) = handle_client(stream) {
eprintln!("Error handling client: {}", e);
}
});
}
Err(e) => {
eprintln!("Connection failed: {}", e);
}
}
}
Ok(())
}
// HTTP client using reqwest (in Cargo.toml: reqwest = { version = "0.11", features = ["blocking"] })
use reqwest::blocking::Client;
fn make_request() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new();
let response = client
.get("https://api.github.com/repos/rust-lang/rust")
.header("User-Agent", "Rust-Client")
.send()?;
println!("Status: {}", response.status());
println!("Headers: {:#?}", response.headers());
let body = response.text()?;
println!("Body: {}", body);
Ok(())
}
fn main() -> std::io::Result<()> {
// Start server in a separate thread for demo
std::thread::spawn(|| {
if let Err(e) = start_server() {
eprintln!("Server error: {}", e);
}
});
// Give server time to start
std::thread::sleep(std::time::Duration::from_secs(1));
// Make client request
if let Err(e) = make_request() {
eprintln!("Request failed: {}", e);
}
Ok(())
}

8. Color Output

ANSI Color Codes

// ANSI color codes
const RESET: &str = "\x1b[0m";
const BLACK: &str = "\x1b[30m";
const RED: &str = "\x1b[31m";
const GREEN: &str = "\x1b[32m";
const YELLOW: &str = "\x1b[33m";
const BLUE: &str = "\x1b[34m";
const MAGENTA: &str = "\x1b[35m";
const CYAN: &str = "\x1b[36m";
const WHITE: &str = "\x1b[37m";
// Background colors
const BG_RED: &str = "\x1b[41m";
const BG_GREEN: &str = "\x1b[42m";
const BG_YELLOW: &str = "\x1b[43m";
const BG_BLUE: &str = "\x1b[44m";
// Text styles
const BOLD: &str = "\x1b[1m";
const UNDERLINE: &str = "\x1b[4m";
const REVERSE: &str = "\x1b[7m";
fn color_demo() {
println!("{}Red text{}", RED, RESET);
println!("{}Green text{}", GREEN, RESET);
println!("{}Blue text{}", BLUE, RESET);
println!("{}{}Bold red text{}", BOLD, RED, RESET);
println!("{}{}Underlined green text{}", UNDERLINE, GREEN, RESET);
println!("{}Background red{}", BG_RED, RESET);
println!("{}{}Bold yellow on blue background{}", BOLD, BG_BLUE, RESET);
// Rainbow text
let text = "RAINBOW";
let colors = [RED, YELLOW, GREEN, CYAN, BLUE, MAGENTA];
for (i, c) in text.chars().enumerate() {
print!("{}{}", colors[i % colors.len()], c);
}
println!("{}", RESET);
}
// Using colored crate (in Cargo.toml: colored = "2")
use colored::*;
fn colored_crate_demo() {
println!("{}", "Red text".red());
println!("{}", "Green text".green());
println!("{}", "Blue text".blue());
println!("{}", "Bold text".bold());
println!("{}", "Underlined".underline());
println!("{}", "Italic".italic());
println!("{}", "Red on blue".red().on_blue());
println!("{}", "Bold yellow".yellow().bold());
// Complex formatting
let value = 42;
println!("The answer is {}!",
value.to_string().green().bold());
// Conditional coloring
let statuses = vec![200, 404, 500, 200, 301];
for status in statuses {
match status {
200 => println!("{}", status.to_string().green()),
301 | 302 => println!("{}", status.to_string().yellow()),
400..=499 => println!("{}", status.to_string().red()),
500..=599 => println!("{}", status.to_string().red().bold()),
_ => println!("{}", status.to_string().white()),
}
}
}
fn main() {
println!("ANSI Colors:");
color_demo();
println!("\nColored Crate:");
colored_crate_demo();
}

9. Redirecting Output

Capturing Output

use std::io::{self, Write};
struct CaptureOutput {
buffer: Vec<u8>,
}
impl Write for CaptureOutput {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.buffer.extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
fn main() {
// Capture stdout temporarily
let mut captured = CaptureOutput { buffer: Vec::new() };
{
// Redirect stdout to our capture
let original_stdout = std::io::stdout();
let mut handle = original_stdout.lock();
// Write directly to capture
writeln!(&mut captured, "This is captured").unwrap();
writeln!(&mut captured, "Another line").unwrap();
}
// Convert captured bytes to string
let captured_output = String::from_utf8(captured.buffer).unwrap();
println!("Captured output:\n{}", captured_output);
// Using std::process::Output
use std::process::Command;
let output = Command::new("echo")
.arg("Hello from command")
.output()
.expect("Failed to execute command");
println!("Command stdout: {}", String::from_utf8_lossy(&output.stdout));
println!("Command stderr: {}", String::from_utf8_lossy(&output.stderr));
}

10. Performance Optimization

Buffered vs Unbuffered Output

use std::io::{self, Write, BufWriter};
use std::time::Instant;
fn unbuffered_write() -> io::Result<()> {
let start = Instant::now();
let mut file = std::fs::File::create("unbuffered.txt")?;
for i in 0..100_000 {
writeln!(file, "Line {}", i)?;
}
println!("Unbuffered: {:?}", start.elapsed());
Ok(())
}
fn buffered_write() -> io::Result<()> {
let start = Instant::now();
let file = std::fs::File::create("buffered.txt")?;
let mut writer = BufWriter::new(file);
for i in 0..100_000 {
writeln!(writer, "Line {}", i)?;
}
writer.flush()?;
println!("Buffered: {:?}", start.elapsed());
Ok(())
}
fn main() -> io::Result<()> {
// Performance comparison
unbuffered_write()?;
buffered_write()?;
// Memory buffer for speed
let mut buffer = Vec::with_capacity(1024 * 1024); // 1MB buffer
// Write to memory buffer first
for i in 0..100_000 {
writeln!(&mut buffer, "Line {}", i)?;
}
// Then write to file in one go
let start = Instant::now();
std::fs::write("memory_buffered.txt", &buffer)?;
println!("Memory buffered write: {:?}", start.elapsed());
Ok(())
}

11. Serialization Output

JSON Serialization

use serde::{Serialize, Deserialize};
use serde_json::{json, Value};
#[derive(Serialize, Deserialize, Debug)]
struct Data {
id: u32,
name: String,
tags: Vec<String>,
metadata: std::collections::HashMap<String, Value>,
}
fn json_examples() -> Result<(), Box<dyn std::error::Error>> {
// Creating JSON directly
let json_data = json!({
"id": 1,
"name": "Example",
"tags": ["rust", "json", "serialization"],
"metadata": {
"created": "2024-01-01",
"version": 1.0
}
});
println!("JSON from macro:\n{}", serde_json::to_string_pretty(&json_data)?);
// From struct
let data = Data {
id: 2,
name: "Structured Data".to_string(),
tags: vec!["test".to_string(), "example".to_string()],
metadata: {
let mut map = std::collections::HashMap::new();
map.insert("priority".to_string(), json!("high"));
map.insert("count".to_string(), json!(42));
map
},
};
println!("\nJSON from struct:\n{}", serde_json::to_string_pretty(&data)?);
// Stream JSON to file
let file = std::fs::File::create("data.json")?;
serde_json::to_writer_pretty(file, &data)?;
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
json_examples()?;
Ok(())
}

YAML and TOML Output

use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize, Debug)]
struct Config {
server: ServerConfig,
database: DatabaseConfig,
logging: LoggingConfig,
}
#[derive(Serialize, Deserialize, Debug)]
struct ServerConfig {
host: String,
port: u16,
workers: usize,
}
#[derive(Serialize, Deserialize, Debug)]
struct DatabaseConfig {
url: String,
pool_size: u32,
timeout_seconds: u64,
}
#[derive(Serialize, Deserialize, Debug)]
struct LoggingConfig {
level: String,
file: String,
}
fn output_formats() -> Result<(), Box<dyn std::error::Error>> {
let config = Config {
server: ServerConfig {
host: "127.0.0.1".to_string(),
port: 8080,
workers: 4,
},
database: DatabaseConfig {
url: "postgresql://localhost/mydb".to_string(),
pool_size: 10,
timeout_seconds: 30,
},
logging: LoggingConfig {
level: "info".to_string(),
file: "app.log".to_string(),
},
};
// YAML output
let yaml = serde_yaml::to_string(&config)?;
println!("YAML:\n{}", yaml);
std::fs::write("config.yaml", yaml)?;
// TOML output
let toml = toml::to_string_pretty(&config)?;
println!("\nTOML:\n{}", toml);
std::fs::write("config.toml", toml)?;
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
output_formats()?;
Ok(())
}

Conclusion

Rust provides a comprehensive set of tools for output operations:

Console Output: println!, print!, eprintln! for basic output
Formatted Output: Format strings with precision, alignment, and padding
Custom Formatting: Implementing Display and Debug traits
File I/O: Buffered and unbuffered writing, appending, binary output
Structured Data: JSON, YAML, TOML, CSV serialization
Logging: Built-in and external logging frameworks
Network Output: HTTP servers and clients
Visual Output: Progress bars, colored text, tables
Performance: Buffered writing for optimal performance

The choice of output method depends on:

Performance requirements: Use buffered writers for large data
Format requirements: Structured vs unstructured data
User experience: Progress indicators and colored output
Debugging needs: Logging with different levels
Data persistence: File I/O with various formats

Rust's output system is designed to be both powerful and safe, with compile-time checking of format strings and proper resource management through ownership and borrowing.