I/O

File and stream I/O operations.

Reading Files

use std::io::File;

let content = File::read_to_string("data.txt");
match content {
    Result::Ok(text) => process(text),
    Result::Err(e) => println!("Error: {}", e),
}

Writing Files

use std::io::File;

let result = File::write_string("output.txt", "Hello, world!");
match result {
    Result::Ok(_) => println!("Written successfully"),
    Result::Err(e) => println!("Error: {}", e),
}

Reading Lines

use std::io::File;

let lines = File::read_lines("data.txt");
match lines {
    Result::Ok(lines) => {
        for line in lines {
            process_line(line);
        }
    }
    Result::Err(e) => println!("Error: {}", e),
}

Standard Streams

use std::io::{stdin, stdout, stderr};

// Read from stdin
let line = stdin::read_line();

// Write to stdout
stdout::write("Hello\n");

// Write to stderr
stderr::write("Error message\n");

Path Operations

use std::io::Path;

let p = Path::new("/home/user/data.txt");
let exists = p.exists();
let is_file = p.is_file();
let is_dir = p.is_dir();
let parent = p.parent();        // Option<Path>
let filename = p.file_name();   // Option<String>
let ext = p.extension();        // Option<String>

Directory Operations

use std::io::{create_dir, read_dir, remove_dir};

create_dir("output");

let entries = read_dir(".");
match entries {
    Result::Ok(files) => {
        for entry in files {
            println!("{}", entry.name());
        }
    }
    Result::Err(e) => println!("Error: {}", e),
}

Buffered I/O

For performance-critical I/O, use buffered readers and writers:

use std::io::{BufReader, BufWriter};

let reader = BufReader::new(File::open("large.txt"));
let writer = BufWriter::new(File::create("output.txt"));