2026년 Rust 에러 핸들링 완벽 가이드: Result, Option, thiserror, anyhow 실전 활용법

use std::fs::File;
use std::io::{self, Read};

fn read_file_contents(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file_contents("config.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

fn find_user_by_id(users: &[User], id: u64) -> Option<&User> {
    users.iter().find(|user| user.id == id)
}

struct User {
    id: u64,
    name: String,
}

fn main() {
    let users = vec![
        User { id: 1, name: String::from("Alice") },
        User { id: 2, name: String::from("Bob") },
    ];
    
    match find_user_by_id(&users, 1) {
        Some(user) => println!("Found user: {}", user.name),
        None => println!("User not found"),
    }
}

use std::fs::File;
use std::io::{self, Read, Write};

fn copy_file_contents(src: &str, dst: &str) -> Result<(), io::Error> {
    let mut source = File::open(src)?;
    let mut destination = File::create(dst)?;
    
    let mut buffer = Vec::new();
    source.read_to_end(&mut buffer)?;
    destination.write_all(&buffer)?;
    
    Ok(())
}

use std::fs::File;
use std::io::{self, Read};
use std::num::ParseIntError;

#[derive(Debug)]
enum ConfigError {
    Io(io::Error),
    Parse(ParseIntError),
}

impl From<io::Error> for ConfigError {
    fn from(err: io::Error) -> ConfigError {
        ConfigError::Io(err)
    }
}

impl From<ParseIntError> for ConfigError {
    fn from(err: ParseIntError) -> ConfigError {
        ConfigError::Parse(err)
    }
}

fn read_config_value(path: &str) -> Result<i32, ConfigError> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    let value: i32 = contents.trim().parse()?;
    Ok(value)
}

use thiserror::Error;
use std::io;

#[derive(Error, Debug)]
pub enum DatabaseError {
    #[error("Connection failed: {0}")]
    ConnectionFailed(String),
    
    #[error("Query execution failed: {query}")]
    QueryFailed {
        query: String,
        #[source]
        source: io::Error,
    },
    
    #[error("Record not found: id={id}")]
    NotFound { id: u64 },
    
    #[error(transparent)]
    Io(#[from] io::Error),
}

fn execute_query(query: &str) -> Result<Vec<String>, DatabaseError> {
    if query.is_empty() {
        return Err(DatabaseError::QueryFailed {
            query: query.to_string(),
            source: io::Error::new(io::ErrorKind::InvalidInput, "Empty query"),
        });
    }
    
    Ok(vec![String::from("result1"), String::from("result2")])
}

use anyhow::{Context, Result, bail, ensure};
use std::fs::File;
use std::io::Read;

fn load_configuration(path: &str) -> Result<Config> {
    ensure!(!path.is_empty(), "Configuration path cannot be empty");
    
    let mut file = File::open(path)
        .with_context(|| format!("Failed to open configuration file: {}", path))?;
    
    let mut contents = String::new();
    file.read_to_string(&mut contents)
        .context("Failed to read configuration file")?;
    
    let config: Config = serde_json::from_str(&contents)
        .context("Failed to parse configuration JSON")?;
    
    if config.timeout == 0 {
        bail!("Invalid configuration: timeout must be greater than 0");
    }
    
    Ok(config)
}

#[derive(serde::Deserialize)]
struct Config {
    timeout: u64,
    host: String,
}

// 라이브러리 코드 (thiserror 사용)
mod library {
    use thiserror::Error;
    
    #[derive(Error, Debug)]
    pub enum LibraryError {
        #[error("Invalid input: {0}")]
        InvalidInput(String),
        
        #[error("Processing failed")]
        ProcessingFailed(#[source] std::io::Error),
    }
    
    pub fn process_data(data: &[u8]) -> Result<Vec<u8>, LibraryError> {
        if data.is_empty() {
            return Err(LibraryError::InvalidInput("Data cannot be empty".into()));
        }
        Ok(data.to_vec())
    }
}

// 애플리케이션 코드 (anyhow 사용)
mod application {
    use anyhow::{Context, Result};
    use super::library;
    
    pub fn run_application() -> Result<()> {
        let data = std::fs::read("input.bin")
            .context("Failed to read input file")?;
        
        let processed = library::process_data(&data)
            .context("Data processing failed")?;
        
        std::fs::write("output.bin", &processed)
            .context("Failed to write output file")?;
        
        Ok(())
    }
}

// 피해야 할 패턴
fn get_first_element_bad(vec: &[i32]) -> i32 {
    vec[0] // 패닉 가능성
}

// 권장 패턴
fn get_first_element_good(vec: &[i32]) -> Option<i32> {
    vec.first().copied()
}

// 또는 Result 반환
fn get_first_element_result(vec: &[i32]) -> Result<i32, &'static str> {
    vec.first().copied().ok_or("Vector is empty")
}

use anyhow::{Context, Result};
use std::fs::File;
use std::io::Read;

fn load_user_preferences(user_id: u64) -> Result<Preferences> {
    let path = format!("/home/{}/.config/app/preferences.json", user_id);
    
    let mut file = File::open(&path)
        .with_context(|| format!("Failed to open preferences for user {}", user_id))?;
    
    let mut contents = String::new();
    file.read_to_string(&mut contents)
        .with_context(|| format!("Failed to read preferences file: {}", path))?;
    
    serde_json::from_str(&contents)
        .with_context(|| "Failed to parse preferences JSON")
}

#[derive(serde::Deserialize)]
struct Preferences {
    theme: String,
}

use thiserror::Error;

pub type Result<T> = std::result::Result<T, AppError>;

#[derive(Error, Debug)]
pub enum AppError {
    #[error("Database error: {0}")]
    Database(#[from] DatabaseError),
    
    #[error("Network error: {0}")]
    Network(#[from] NetworkError),
    
    #[error("Configuration error: {0}")]
    Config(String),
}

#[derive(Error, Debug)]
pub enum DatabaseError {
    #[error("Connection lost")]
    ConnectionLost,
}

#[derive(Error, Debug)]
pub enum NetworkError {
    #[error("Timeout")]
    Timeout,
}