How do you perform I/O in Rust?

Performing input and output (I/O) operations in Rust is handled through modules in the standard library, primarily via the std::io module. This module provides various tools for handling I/O tasks, including file operations, network communication, and data read/write operations via standard input/output (stdin/stdout). The following are common I/O operations and their implementations in Rust:

1. Reading and Writing Files

In Rust, the std::fs module is used for file operations, while the std::io module provides generic traits and structs for reading and writing data.

Example: How to read the contents of a file and print it to the console.

rust
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;

fn main() -> std::io::Result<()> {
    let file = File::open("example.txt")?;
    let reader = BufReader::new(file);

    for line in reader.lines() {
        println!("{}", line?);
    }

    Ok(())
}

2. Standard Input and Output

Rust processes standard input and output using the stdin() and stdout() functions from std::io.

Example: How to read a line from standard input and write it to standard output.

rust
use std::io::{self, Write};

fn main() {
    let mut input = String::new();
    println!("Please enter some text:");
    io::stdin().read_line(&mut input).expect("Failed to read line");

    print!("You typed: {}", input);
    io::stdout().flush().unwrap(); // Ensure all output is written
}

3. Error Handling

Rust enforces error handling via the Result type, ensuring that all potential errors are properly handled.

Example: How to handle potential errors when opening a file that does not exist.

rust
use std::fs::File;

fn main() {
    match File::open("does_not_exist.txt") {
        Ok(file) => println!("File opened successfully."),
        Err(err) => println!("Failed to open the file: {:?}", err),
    }
}

These examples illustrate the fundamental approaches to handling I/O in Rust. By leveraging std::io and related modules, Rust offers robust and secure I/O operations.