3장: Rust 타입 시스템과 에러 처리

#[derive(Debug, Clone)]
struct User {
    id: u64,
    name: String,
    email: String,
    active: bool,
}
 
impl User {
    // 연관 함수 (associated function) — 생성자 역할
    fn new(id: u64, name: String, email: String) -> Self {
        Self {
            id,
            name,
            email,
            active: true,
        }
    }
 
    // 메서드 — &self로 불변 빌림
    fn display_name(&self) -> &str {
        &self.name
    }
 
    // 가변 메서드 — &mut self로 가변 빌림
    fn deactivate(&mut self) {
        self.active = false;
    }
}

use serde::{Deserialize, Serialize};
 
// API 응답 모델
#[derive(Debug, Clone, Serialize)]
struct UserResponse {
    id: u64,
    name: String,
    email: String,
}
 
// API 요청 모델
#[derive(Debug, Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}

#[derive(Debug)]
enum PaymentMethod {
    CreditCard { number: String, expiry: String },
    BankTransfer { account: String, bank_code: String },
    DigitalWallet(String), // 지갑 주소
    Cash,
}
 
fn process_payment(method: &PaymentMethod) {
    match method {
        PaymentMethod::CreditCard { number, .. } => {
            println!("카드 결제: ****{}", &number[number.len()-4..]);
        }
        PaymentMethod::BankTransfer { account, bank_code } => {
            println!("계좌이체: {} ({})", account, bank_code);
        }
        PaymentMethod::DigitalWallet(address) => {
            println!("디지털 월렛: {}", address);
        }
        PaymentMethod::Cash => {
            println!("현금 결제");
        }
    }
}

trait Repository {
    type Item;
    type Error;
 
    async fn find_by_id(&self, id: u64) -> Result<Option<Self::Item>, Self::Error>;
    async fn save(&self, item: &Self::Item) -> Result<(), Self::Error>;
    async fn delete(&self, id: u64) -> Result<(), Self::Error>;
 
    // 기본 구현
    async fn exists(&self, id: u64) -> Result<bool, Self::Error> {
        Ok(self.find_by_id(id).await?.is_some())
    }
}
 
struct PostgresUserRepository {
    pool: String, // 실제로는 sqlx::PgPool
}
 
impl Repository for PostgresUserRepository {
    type Item = User;
    type Error = String; // 실제로는 sqlx::Error
 
    async fn find_by_id(&self, id: u64) -> Result<Option<User>, String> {
        // 데이터베이스 조회 로직
        todo!()
    }
 
    async fn save(&self, item: &User) -> Result<(), String> {
        todo!()
    }
 
    async fn delete(&self, id: u64) -> Result<(), String> {
        todo!()
    }
    // exists()는 기본 구현을 사용
}

// Option은 표준 라이브러리에 다음과 같이 정의되어 있습니다
// enum Option<T> {
//     Some(T),
//     None,
// }
 
fn find_user(users: &[User], id: u64) -> Option<&User> {
    users.iter().find(|u| u.id == id)
}
 
fn main() {
    let users = vec![
        User::new(1, "Alice".into(), "alice@example.com".into()),
        User::new(2, "Bob".into(), "bob@example.com".into()),
    ];
 
    // 패턴 매칭으로 처리
    match find_user(&users, 1) {
        Some(user) => println!("찾음: {:?}", user),
        None => println!("사용자 없음"),
    }
 
    // 메서드 체이닝으로 간결하게
    let name = find_user(&users, 3)
        .map(|u| u.display_name())
        .unwrap_or("알 수 없음");
 
    println!("이름: {}", name);
}

// Result는 표준 라이브러리에 다음과 같이 정의되어 있습니다
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }
 
use std::fs;
use std::io;
 
fn read_config(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}
 
fn main() {
    match read_config("config.toml") {
        Ok(content) => println!("설정 내용: {}", content),
        Err(e) => eprintln!("설정 파일 읽기 실패: {}", e),
    }
}

use std::fs;
use std::io;
 
// ? 연산자 없이 — 중첩된 match
fn load_config_verbose(path: &str) -> Result<Config, io::Error> {
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => return Err(e),
    };
    // 파싱 로직...
    Ok(Config { content })
}
 
// ? 연산자 사용 — 깔끔한 코드
fn load_config(path: &str) -> Result<Config, io::Error> {
    let content = fs::read_to_string(path)?;
    // 파싱 로직...
    Ok(Config { content })
}
 
struct Config { content: String }

use thiserror::Error;
 
#[derive(Debug, Error)]
enum AppError {
    #[error("사용자를 찾을 수 없습니다: id={0}")]
    UserNotFound(u64),
 
    #[error("인증 실패: {reason}")]
    AuthenticationFailed { reason: String },
 
    #[error("데이터베이스 오류")]
    Database(#[from] sqlx::Error),
 
    #[error("잘못된 요청: {0}")]
    BadRequest(String),
 
    #[error("내부 서버 오류")]
    Internal(#[from] anyhow::Error),
}

use anyhow::{Context, Result, bail};
 
// anyhow::Result<T>는 Result<T, anyhow::Error>의 축약
async fn initialize_app() -> Result<AppState> {
    let config = load_config("config.toml")
        .context("설정 파일 로드 실패")?;
 
    let db_pool = create_db_pool(&config.database_url)
        .await
        .context("데이터베이스 연결 실패")?;
 
    if config.max_connections == 0 {
        bail!("max_connections는 0보다 커야 합니다");
    }
 
    Ok(AppState { config, db_pool })
}

// 도메인 에러 (thiserror)
#[derive(Debug, thiserror::Error)]
enum UserError {
    #[error("사용자를 찾을 수 없습니다: id={0}")]
    NotFound(u64),
 
    #[error("이메일이 이미 존재합니다: {0}")]
    DuplicateEmail(String),
 
    #[error("데이터베이스 오류")]
    Database(#[from] sqlx::Error),
}
 
// Axum 핸들러에서 에러를 HTTP 응답으로 변환
impl axum::response::IntoResponse for UserError {
    fn into_response(self) -> axum::response::Response {
        let (status, message) = match &self {
            UserError::NotFound(_) => (StatusCode::NOT_FOUND, self.to_string()),
            UserError::DuplicateEmail(_) => (StatusCode::CONFLICT, self.to_string()),
            UserError::Database(_) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "내부 서버 오류".to_string(),
            ),
        };
 
        let body = Json(serde_json::json!({
            "error": message,
        }));
 
        (status, body).into_response()
    }
}

#[derive(Debug)]
enum ServiceError {
    Database(String),
    Validation(String),
}
 
// io::Error를 ServiceError로 자동 변환
impl From<std::io::Error> for ServiceError {
    fn from(err: std::io::Error) -> Self {
        ServiceError::Database(err.to_string())
    }
}
 
fn read_data() -> Result<String, ServiceError> {
    let data = std::fs::read_to_string("data.txt")?; // io::Error → ServiceError 자동 변환
    Ok(data)
}

use anyhow::{Context, Result};
 
async fn handle_create_user(
    Json(req): Json<CreateUserRequest>,
) -> Result<Json<UserResponse>, AppError> {
    // 1. 입력 검증
    validate_email(&req.email)
        .map_err(|e| AppError::BadRequest(e.to_string()))?;
 
    // 2. 비즈니스 로직 — ?로 에러 전파
    let user = create_user(&req)
        .await?; // UserError가 AppError로 자동 변환 (From 트레이트)
 
    // 3. 응답 변환
    Ok(Json(UserResponse::from(user)))
}