Rustにおけるエラー型のネストを活用した複雑な状況の表現方法

use std::fs::File;
use std::io::Error;

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

fn find_item(items: Vec<i32>, target: i32) -> Option<i32> {
    for &item in items.iter() {
        if item == target {
            return Some(item);
        }
    }
    None
}

use std::fmt;
use std::io;
use std::num;

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

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MyError::IoError(e) => write!(f, "I/O error: {}", e),
            MyError::ParseError(e) => write!(f, "Parse error: {}", e),
        }
    }
}

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::IoError(error)
    }
}

impl From<num::ParseIntError> for MyError {
    fn from(error: num::ParseIntError) -> Self {
        MyError::ParseError(error)
    }
}

enum MyError {
    IoError(std::io::Error),
    ParseError(std::num::ParseIntError),
    NetworkError(std::io::Error),
}

fn process_file(file_path: &str) -> Result<(), MyError> {
    let file = std::fs::File::open(file_path).map_err(MyError::IoError)?;
    let mut content = String::new();
    file.read_to_string(&mut content).map_err(MyError::IoError)?;
    let number: i32 = content.trim().parse().map_err(MyError::ParseError)?;
    Ok(())
}

enum MyError {
    IoError(std::io::Error),
    ParseError(std::num::ParseIntError),
    DatabaseError(String),
    NetworkError(std::io::Error),
}

fn handle_error(err: MyError) {
    match err {
        MyError::IoError(e) => println!("I/O error: {}", e),
        MyError::ParseError(e) => println!("Parse error: {}", e),
        MyError::NetworkError(e) => println!("Network error: {}", e),
        MyError::DatabaseError(msg) => println!("Database error: {}", msg),
    }
}

fn handle_error(err: MyError) {
    match err {
        MyError::IoError(_) => {
            // リトライ処理
            println!("Retrying I/O operation...");
        },
        MyError::ParseError(_) => {
            // ユーザーに再入力を求める
            println!("Invalid input. Please try again.");
        },
        _ => {
            // その他のエラーにはエラーメッセージを表示
            println!("An error occurred: {}", err);
        },
    }
}

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

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

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::IoError(error)
    }
}

impl From<ParseIntError> for MyError {
    fn from(error: ParseIntError) -> Self {
        MyError::ParseError(error)
    }
}

fn read_and_parse_file(file_path: &str) -> Result<i32, MyError> {
    let mut file = File::open(file_path).map_err(MyError::IoError)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).map_err(MyError::IoError)?;

    let number: i32 = contents.trim().parse().map_err(MyError::ParseError)?;

    Ok(number)
}

fn main() {
    match read_and_parse_file("data.txt") {
        Ok(value) => println!("Parsed number: {}", value),
        Err(MyError::IoError(e)) => println!("I/O Error: {}", e),
        Err(MyError::ParseError(e)) => println!("Parse Error: {}", e),
    }
}

use std::fmt;
use std::io::{self, Write};
use std::net::TcpStream;
use std::sync::mpsc;

#[derive(Debug)]
enum MyError {
    IoError(io::Error),
    NetworkError(String),
    DatabaseError(String),
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MyError::IoError(e) => write!(f, "I/O Error: {}", e),
            MyError::NetworkError(msg) => write!(f, "Network Error: {}", msg),
            MyError::DatabaseError(msg) => write!(f, "Database Error: {}", msg),
        }
    }
}

fn send_data_to_server(address: &str) -> Result<(), MyError> {
    let mut stream = TcpStream::connect(address).map_err(|e| MyError::NetworkError(e.to_string()))?;
    stream.write_all(b"Hello, server!").map_err(MyError::IoError)?;
    Ok(())
}

fn query_database(query: &str) -> Result<(), MyError> {
    if query == "SELECT * FROM users" {
        Ok(())
    } else {
        Err(MyError::DatabaseError("Invalid query".to_string()))
    }
}

fn main() {
    // ネットワーク通信
    match send_data_to_server("127.0.0.1:8080") {
        Ok(_) => println!("Data sent to server successfully."),
        Err(e) => println!("Error occurred during network communication: {}", e),
    }

    // データベース操作
    match query_database("SELECT * FROM users") {
        Ok(_) => println!("Query executed successfully."),
        Err(e) => println!("Error occurred during database query: {}", e),
    }
}

#[derive(Debug)]
enum AppError {
    ValidationError(String),
    DatabaseError(String),
    ApiError(String),
}

fn validate_user_input(input: &str) -> Result<(), AppError> {
    if input.is_empty() {
        Err(AppError::ValidationError("Input cannot be empty".to_string()))
    } else {
        Ok(())
    }
}

fn connect_to_database() -> Result<(), AppError> {
    Err(AppError::DatabaseError("Failed to connect to database".to_string()))
}

fn call_external_api() -> Result<String, AppError> {
    Err(AppError::ApiError("Failed to fetch data from API".to_string()))
}

fn main() {
    match validate_user_input("") {
        Ok(_) => println!("Input is valid."),
        Err(e) => println!("Error occurred during input validation: {}", e),
    }

    match connect_to_database() {
        Ok(_) => println!("Connected to the database."),
        Err(e) => println!("Error occurred during database connection: {}", e),
    }

    match call_external_api() {
        Ok(response) => println!("API response: {}", response),
        Err(e) => println!("Error occurred while calling external API: {}", e),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // テスト用にエラー型をシンプルにする
    #[derive(Debug, PartialEq)]
    enum MyError {
        IoError(String),
        ParseError(String),
    }

    fn process_file(file_path: &str) -> Result<i32, MyError> {
        if file_path == "invalid_file.txt" {
            return Err(MyError::IoError("File not found".to_string()));
        }
        if file_path == "invalid_data.txt" {
            return Err(MyError::ParseError("Failed to parse data".to_string()));
        }
        Ok(42) // 成功時の戻り値
    }

    #[test]
    fn test_io_error() {
        let result = process_file("invalid_file.txt");
        assert_eq!(result, Err(MyError::IoError("File not found".to_string())));
    }

    #[test]
    fn test_parse_error() {
        let result = process_file("invalid_data.txt");
        assert_eq!(result, Err(MyError::ParseError("Failed to parse data".to_string())));
    }

    #[test]
    fn test_success() {
        let result = process_file("valid_file.txt");
        assert_eq!(result, Ok(42));
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Debug, PartialEq)]
    enum MyError {
        IoError(String),
        ParseError(String),
    }

    fn process_file(file_path: &str) -> Result<i32, MyError> {
        if file_path == "not_found.txt" {
            return Err(MyError::IoError("File not found".to_string()));
        }
        if file_path == "bad_data.txt" {
            return Err(MyError::ParseError("Invalid format".to_string()));
        }
        Ok(100)
    }

    #[test]
    fn test_io_error_with_match() {
        let result = process_file("not_found.txt");

        match result {
            Err(MyError::IoError(msg)) => assert_eq!(msg, "File not found"),
            _ => panic!("Expected IoError"),
        }
    }

    #[test]
    fn test_parse_error_with_match() {
        let result = process_file("bad_data.txt");

        match result {
            Err(MyError::ParseError(msg)) => assert_eq!(msg, "Invalid format"),
            _ => panic!("Expected ParseError"),
        }
    }

    #[test]
    fn test_success_with_match() {
        let result = process_file("valid_file.txt");

        match result {
            Ok(value) => assert_eq!(value, 100),
            Err(_) => panic!("Expected Ok result"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // エラー型のネスト
    #[derive(Debug, PartialEq)]
    enum MyError {
        IoError(String),
        ParseError(String),
        TimeoutError(String),
    }

    fn fetch_data_from_server(server: &str) -> Result<String, MyError> {
        if server == "timeout_server" {
            return Err(MyError::TimeoutError("Connection timed out".to_string()));
        }
        if server == "server_not_found" {
            return Err(MyError::IoError("Server not found".to_string()));
        }
        Ok("Data fetched successfully".to_string())
    }

    #[test]
    fn test_timeout_error() {
        let result = fetch_data_from_server("timeout_server");

        assert_eq!(result, Err(MyError::TimeoutError("Connection timed out".to_string())));
    }

    #[test]
    fn test_io_error() {
        let result = fetch_data_from_server("server_not_found");

        assert_eq!(result, Err(MyError::IoError("Server not found".to_string())));
    }

    #[test]
    fn test_success() {
        let result = fetch_data_from_server("valid_server");

        assert_eq!(result, Ok("Data fetched successfully".to_string()));
    }
}

#[derive(Debug)]
enum MyError {
    IoError(String),
    NetworkError(String),
    ParseError(String),
}

use std::io::{self, Write};
use std::net::TcpStream;

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

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::IoError(error)
    }
}

fn send_data_to_server(address: &str) -> Result<(), MyError> {
    let mut stream = TcpStream::connect(address)?;
    stream.write_all(b"Hello, server!")?;
    Ok(())
}

use std::fmt;

#[derive(Debug)]
enum MyError {
    IoError(String),
    NetworkError(String),
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MyError::IoError(msg) => write!(f, "I/O Error: {}", msg),
            MyError::NetworkError(msg) => write!(f, "Network Error: {}", msg),
        }
    }
}

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

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

#[derive(Debug)]
enum NetworkError {
    ConnectionFailed,
    Timeout,
}

#[derive(Debug)]
enum FileError {
    FileNotFound,
    PermissionDenied,
}

#[derive(Debug)]
enum AppError {
    Network(NetworkError),
    File(FileError),
}

impl From<NetworkError> for AppError {
    fn from(error: NetworkError) -> Self {
        AppError::Network(error)
    }
}

impl From<FileError> for AppError {
    fn from(error: FileError) -> Self {
        AppError::File(error)
    }
}

fn handle_error() -> Result<(), MyError> {
    let result: Result<(), MyError> = Err(MyError::NetworkError("Timeout".to_string()));

    result.map_err(|e| {
        // エラーログを記録
        eprintln!("Error: {}", e);
        e
    })?;

    Ok(())
}

use reqwest::{self, StatusCode};
use serde::Deserialize;

#[derive(Debug)]
enum ApiError {
    HttpError(reqwest::Error),
    InvalidResponse(String),
    NotFound(String),
    Unauthorized(String),
}

#[derive(Deserialize)]
struct ApiResponse {
    data: String,
}

fn fetch_data(url: &str) -> Result<ApiResponse, ApiError> {
    let response = reqwest::blocking::get(url)
        .map_err(ApiError::HttpError)?;

    match response.status() {
        StatusCode::OK => {
            let api_response: ApiResponse = response.json().map_err(|e| ApiError::InvalidResponse(e.to_string()))?;
            Ok(api_response)
        },
        StatusCode::NOT_FOUND => Err(ApiError::NotFound("Resource not found".to_string())),
        StatusCode::UNAUTHORIZED => Err(ApiError::Unauthorized("Unauthorized access".to_string())),
        _ => Err(ApiError::InvalidResponse("Unexpected response".to_string())),
    }
}

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

#[derive(Debug)]
enum FileError {
    IoError(io::Error),
    PermissionDenied(String),
    FileNotFound(String),
}

fn write_to_file(file_path: &str, content: &str) -> Result<(), FileError> {
    let file = File::create(file_path).map_err(|e| match e.kind() {
        io::ErrorKind::PermissionDenied => FileError::PermissionDenied(format!("Permission denied for {}", file_path)),
        io::ErrorKind::NotFound => FileError::FileNotFound(format!("File not found: {}", file_path)),
        _ => FileError::IoError(e),
    })?;

    writeln!(file, "{}", content).map_err(|e| FileError::IoError(e))?;
    Ok(())
}

use std::fmt;

#[derive(Debug)]
enum DbError {
    ConnectionError(String),
    QueryError(String),
    IntegrityError(String),
}

impl fmt::Display for DbError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DbError::ConnectionError(msg) => write!(f, "Connection Error: {}", msg),
            DbError::QueryError(msg) => write!(f, "Query Error: {}", msg),
            DbError::IntegrityError(msg) => write!(f, "Integrity Error: {}", msg),
        }
    }
}

fn connect_to_db() -> Result<(), DbError> {
    // 偽の接続エラーを模擬
    Err(DbError::ConnectionError("Failed to connect to database".to_string()))
}

fn query_db(query: &str) -> Result<String, DbError> {
    if query == "SELECT * FROM users" {
        Err(DbError::QueryError("Invalid SQL query".to_string()))
    } else {
        Ok("Query successful".to_string())
    }
}

fn main() {
    match connect_to_db() {
        Ok(_) => println!("Connected to DB"),
        Err(e) => eprintln!("Error: {}", e),
    }

    match query_db("SELECT * FROM users") {
        Ok(result) => println!("Query Result: {}", result),
        Err(e) => eprintln!("Error: {}", e),
    }
}

#[derive(Debug)]
enum AppError {
    FileError(FileError),
    ApiError(ApiError),
}

impl From<FileError> for AppError {
    fn from(err: FileError) -> Self {
        AppError::FileError(err)
    }
}

impl From<ApiError> for AppError {
    fn from(err: ApiError) -> Self {
        AppError::ApiError(err)
    }
}

fn handle_file_operation() -> Result<(), AppError> {
    let result = write_to_file("example.txt", "Hello, World!");
    result.map_err(AppError::from)
}

fn handle_api_call() -> Result<String, AppError> {
    let result = fetch_data("https://example.com/api");
    result.map_err(AppError::from)
}

fn main() {
    match handle_file_operation() {
        Ok(_) => println!("File operation succeeded."),
        Err(e) => eprintln!("File operation failed: {:?}", e),
    }

    match handle_api_call() {
        Ok(data) => println!("API call succeeded: {}", data),
        Err(e) => eprintln!("API call failed: {:?}", e),
    }
}

use std::fmt;

#[derive(Debug)]
enum DatabaseError {
    ConnectionError(String),
    QueryError(String),
}

#[derive(Debug)]
enum FileError {
    NotFound(String),
    PermissionDenied(String),
}

trait AppError: fmt::Debug + fmt::Display {}

impl AppError for DatabaseError {}
impl AppError for FileError {}

impl fmt::Display for DatabaseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DatabaseError::ConnectionError(msg) => write!(f, "Database Connection Error: {}", msg),
            DatabaseError::QueryError(msg) => write!(f, "Database Query Error: {}", msg),
        }
    }
}

impl fmt::Display for FileError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            FileError::NotFound(msg) => write!(f, "File Not Found: {}", msg),
            FileError::PermissionDenied(msg) => write!(f, "Permission Denied: {}", msg),
        }
    }
}

fn handle_error<E: AppError>(error: E) {
    eprintln!("Error: {}", error);
}

use std::fmt;
use std::io;

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

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::DatabaseError(msg) => write!(f, "Database Error: {}", msg),
        }
    }
}

fn perform_file_operation(file_path: &str) -> Result<(), MyError> {
    let file = std::fs::File::open(file_path).map_err(|e| MyError::IoError(e))?;
    // ... (ファイル操作)
    Ok(())
}

fn execute_query(query: &str) -> Result<(), MyError> {
    if query == "INVALID" {
        Err(MyError::DatabaseError("Invalid SQL query".to_string()))
    } else {
        Ok(())
    }
}

fn main() {
    if let Err(e) = perform_file_operation("data.txt") {
        eprintln!("File operation failed: {}", e);
    }

    if let Err(e) = execute_query("INVALID") {
        eprintln!("Query execution failed: {}", e);
    }
}

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

fn read_file(file_path: &str) -> Result<String, MyError> {
    let content = std::fs::read_to_string(file_path).map_err(MyError::IoError)?;
    Ok(content)
}

fn parse_content(content: &str) -> Result<i32, MyError> {
    content.trim().parse().map_err(|e| MyError::ParseError(e.to_string()))
}

fn process_file(file_path: &str) -> Result<i32, MyError> {
    let content = read_file(file_path)?;
    let result = parse_content(&content)?;
    Ok(result)
}

fn main() {
    match process_file("data.txt") {
        Ok(value) => println!("Processed result: {}", value),
        Err(e) => eprintln!("Error: {}", e),
    }
}

#[derive(Debug)]
enum RetryableError {
    NetworkError(String),
    TimeoutError(String),
    OtherError(String),
}

fn perform_action() -> Result<(), RetryableError> {
    // 偽のネットワークエラー
    Err(RetryableError::NetworkError("Temporary network failure".to_string()))
}

fn retry_operation() -> Result<(), RetryableError> {
    let max_retries = 3;
    let mut retries = 0;

    loop {
        match perform_action() {
            Ok(_) => return Ok(()),
            Err(e) if retries < max_retries => {
                retries += 1;
                eprintln!("Retry {}/{}: {}", retries, max_retries, e);
                continue;
            }
            Err(e) => return Err(e),
        }
    }
}

fn main() {
    match retry_operation() {
        Ok(_) => println!("Operation succeeded."),
        Err(e) => eprintln!("Operation failed: {}", e),
    }
}

use reqwest::Error as ReqwestError;
use serde_json::Error as SerdeError;

#[derive(Debug)]
enum ApiError {
    RequestFailed(ReqwestError),
    ParseFailed(SerdeError),
    InvalidResponse(String),
}

fn fetch_data_from_api(url: &str) -> Result<String, ApiError> {
    let response = reqwest::blocking::get(url).map_err(ApiError::RequestFailed)?;

    if !response.status().is_success() {
        return Err(ApiError::InvalidResponse(format!(
            "Received non-200 status: {}",
            response.status()
        )));
    }

    let body = response.text().map_err(ApiError::RequestFailed)?;
    let json_data: serde_json::Value = serde_json::from_str(&body).map_err(ApiError::ParseFailed)?;

    Ok(json_data.to_string())
}

fn main() {
    match fetch_data_from_api("https://api.example.com/data") {
        Ok(data) => println!("Fetched data: {}", data),
        Err(e) => eprintln!("Error occurred: {:?}", e),
    }
}

use std::fs;
use std::io;
use std::path::Path;

#[derive(Debug)]
enum FileError {
    NotFound(io::Error),
    PermissionDenied(io::Error),
    DiskFull(io::Error),
    Unknown(io::Error),
}

fn read_file(path: &str) -> Result<String, FileError> {
    let path = Path::new(path);

    if !path.exists() {
        return Err(FileError::NotFound(io::Error::new(io::ErrorKind::NotFound, "File not found")));
    }

    let content = fs::read_to_string(path).map_err(|e| match e.kind() {
        io::ErrorKind::PermissionDenied => FileError::PermissionDenied(e),
        io::ErrorKind::DiskFull => FileError::DiskFull(e),
        _ => FileError::Unknown(e),
    })?;

    Ok(content)
}

fn main() {
    match read_file("config.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(e) => eprintln!("Error occurred: {:?}", e),
    }
}

use std::thread;
use std::sync::mpsc;
use std::time::Duration;

#[derive(Debug)]
enum ThreadError {
    WorkerFailed(String),
    Timeout,
}

fn run_worker() -> Result<i32, ThreadError> {
    thread::sleep(Duration::from_secs(2));
    Err(ThreadError::WorkerFailed("Worker failed due to some reason".to_string()))
}

fn main() {
    let (tx, rx) = mpsc::channel();

    let handle = thread::spawn(move || {
        match run_worker() {
            Ok(result) => tx.send(Ok(result)).unwrap(),
            Err(e) => tx.send(Err(e)).unwrap(),
        }
    });

    match rx.recv() {
        Ok(Ok(result)) => println!("Worker completed successfully: {}", result),
        Ok(Err(e)) => eprintln!("Worker failed: {:?}", e),
        Err(_) => eprintln!("Timeout occurred"),
    }

    handle.join().unwrap();
}