[Rust] 에러 처리와 panic: 안정적인 코드 작성법

Rust의 에러 처리: 안정성과 효율성을 극대화하는 방법

Rust는 안전성과 효율성을 철학으로 하는 시스템 프로그래밍 언어로, 에러 처리 메커니즘 또한 이를 중심으로 설계되었습니다. Rust의 에러 처리는 두 가지 주요 유형으로 나뉩니다:

1. 복구 가능한 에러: Result<T, E> 타입을 사용해 처리.
2. 복구 불가능한 에러: panic! 매크로를 사용해 처리.

Rust의 에러 처리 방식을 이해하면 안정적이고 유지보수 가능한 코드를 작성할 수 있습니다. 이번 글에서는 Rust의 에러 처리 모델과 실제 코드 예제를 통해 개념을 깊이 이해하고, 효율적인 에러 처리 방법을 소개합니다.

---

1. Rust 에러 처리의 주요 특징

1.1 복구 가능한 에러: Result 타입

Rust의 Result<T, E> 타입은 함수 실행의 성공 또는 실패 여부를 나타냅니다. Result는 다음과 같은 두 가지 상태를 가집니다:

• Ok(T): 작업 성공. 성공 결과 값을 포함.
• Err(E): 작업 실패. 에러 정보를 포함.

Rust의 Result 타입은 함수 결과를 명시적으로 처리하게 하여 안정성을 보장합니다.

예제:

use std::fs::File;

fn main() {
    let file = File::open("example.txt");

    match file {
        Ok(file) => println!("File opened successfully: {:?}", file),
        Err(e) => println!("Failed to open file: {}", e),
    }
}

• File::open은 파일 열기 시도가 성공하면 Ok를 반환하고, 실패하면 Err를 반환합니다.
• match 문을 사용해 성공/실패를 처리합니다.

1.2 복구 불가능한 에러: panic! 매크로

panic!은 복구가 불가능한 에러 상황에서 사용되며, 프로그램을 즉시 종료합니다.

예제:

fn main() {
    panic!("Critical error occurred!");
}

• panic!은 주로 논리적 오류 또는 치명적 문제 상황에서 사용되며, 불필요한 사용은 피하는 것이 좋습니다.

---

2. Result 타입을 활용한 에러 처리

2.1 기본적인 에러 처리

Result 타입은 match 문으로 분기 처리합니다.

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

2.2 unwrap과 expect를 사용한 간결한 처리

• unwrap: 성공 시 값을 반환하고, 실패 시 panic! 호출.
• expect: 실패 시 커스텀 메시지를 출력하며 panic! 호출.

예제:

fn main() {
    let number = "123".parse::<i32>().unwrap();
    println!("Parsed number: {}", number);

    let fail = "abc".parse::<i32>().expect("Failed to parse string to number");
}

주의: 프로덕션 코드에서는 사용을 최소화하고 명시적으로 에러를 처리하세요.

2.3 ? 연산자를 사용한 에러 전파

? 연산자는 에러를 호출자에게 간단히 전파할 수 있는 강력한 도구입니다.

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

fn read_file(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("example.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => println!("Error reading file: {}", e),
    }
}

• ?는 Err 값을 발견하면 즉시 반환합니다.
• 코드 가독성을 높이고 중복 처리를 줄이는 데 유용합니다.

---

3. Rust 에러 타입의 세부 관리

3.1 커스텀 에러 타입 정의

Rust에서는 고유한 에러 타입을 만들어 에러를 더 명확히 표현할 수 있습니다.

use std::fmt;

#[derive(Debug)]
enum MyError {
    IoError(std::io::Error),
    ParseError,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MyError::IoError(e) => write!(f, "IO Error: {}", e),
            MyError::ParseError => write!(f, "Parse Error"),
        }
    }
}

3.2 thiserror를 이용한 간단한 에러 정의

thiserror 크레이트를 활용하면 복잡한 에러 타입 정의를 간결화할 수 있습니다.

use thiserror::Error;

#[derive(Error, Debug)]
enum MyError {
    #[error("IO error occurred: {0}")]
    Io(#[from] std::io::Error),

    #[error("Parse error occurred")]
    Parse,
}

• 간결한 문법으로 다양한 에러를 처리할 수 있습니다.

---

4. Rust 에러 처리 Best Practices

4.1 복구 가능한 에러와 불가능한 에러의 명확한 구분

• 복구 가능: Result를 사용해 호출자가 처리할 수 있도록 전달.
• 복구 불가능: panic!을 사용하되, 사용 빈도를 최소화.

4.2 사용자 친화적인 에러 메시지 작성

• 명확하고 구체적인 에러 메시지를 통해 디버깅과 사용자 경험을 향상.

4.3 ? 연산자의 적극 활용

• 에러 전파를 간소화하고 중복 코드를 줄임.

---

F&Q: Rust 에러 처리에서 자주 묻는 질문

Q1: unwrap과 expect를 사용해도 괜찮은 경우는 언제인가요?

• 테스트 코드 또는 간단한 스크립트에서만 사용하세요. 프로덕션 코드에서는 명시적으로 에러를 처리하세요.

Q2: ? 연산자는 모든 함수에서 사용할 수 있나요?

• Result 또는 Option 타입을 반환하는 함수에서만 사용할 수 있습니다.

Q3: 복잡한 에러를 효율적으로 처리하려면 어떻게 해야 하나요?

• thiserror와 같은 라이브러리를 사용해 에러 정의를 간결화하세요.

Q4: 프로그램 실행을 중단하지 않고 에러를 처리하려면?

• match 문 또는 unwrap_or, unwrap_or_else 같은 메서드를 활용하세요.

---

결론: Rust 에러 처리가 제공하는 안정성과 효율성

Rust의 에러 처리 모델은 안정적이고 효율적인 프로그램 작성을 가능하게 합니다. Result 타입과 ? 연산자를 적극 활용하면 에러를 효과적으로 처리하고, 코드를 간결하게 유지할 수 있습니다. Rust의 철학을 잘 반영한 에러 처리 방식을 이해하고, 이를 실무 프로젝트에 적용해 보세요. Rust의 에러 처리는 단순한 도구가 아닌, 안전한 프로그래밍의 핵심 철학입니다.