RustのクロージャとOption/Resultを活用したエラー処理の実践例

fn find_value(key: &str) -> Option<i32> {
    match key {
        "key1" => Some(42),
        _ => None,
    }
}

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

let add = |x: i32, y: i32| x + y;
let result = add(5, 3);
println!("Result: {}", result); // Output: 8

let factor = 2;
let multiply = |x: i32| x * factor;
println!("Multiply: {}", multiply(4)); // Output: 8

let mut count = 0;
let mut increment = || {
    count += 1;
    println!("Count: {}", count);
};
increment(); // Count: 1
increment(); // Count: 2

let add: fn(i32, i32) -> i32 = |x, y| x + y;
println!("Sum: {}", add(10, 20)); // Output: 30

fn get_user_age(name: &str) -> Option<u32> {
    match name {
        "Alice" => Some(30),
        "Bob" => Some(25),
        _ => None,
    }
}

if let Some(age) = get_user_age("Alice") {
    println!("Alice's age is {}", age);
} else {
    println!("User not found.");
}

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

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

let value = Some(10);
let doubled = value.map(|x| x * 2).unwrap_or(0);
println!("Doubled: {}", doubled); // Output: 20

fn get_number() -> Option<i32> {
    Some(5)
}

fn main() {
    let result = get_number().map(|x| x * 2);
    println!("{:?}", result); // Output: Some(10)
}

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

fn main() {
    let result = divide(10, 2)
        .map(|x| x * 2) // 成功時に値を2倍
        .map_err(|e| format!("Error: {}", e)); // エラー時にエラーメッセージを装飾
    println!("{:?}", result); // Output: Ok(10)
}

fn parse_number(input: &str) -> Result<i32, String> {
    input.parse::<i32>().map_err(|_| "Failed to parse number".to_string())
}

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

fn main() {
    let input = "10";
    let result = parse_number(input)
        .and_then(|num| divide(num, 2)) // パースと除算を連続して処理
        .map(|x| x * 2); // 結果を加工
    println!("{:?}", result); // Output: Ok(10)
}

fn parse_and_multiply(input: &str, factor: i32) -> Result<i32, String> {
    input
        .parse::<i32>() // 文字列を数値に変換
        .map(|x| x * factor) // 成功時に数値を掛け算
        .map_err(|_| format!("Failed to parse '{}' as an integer", input)) // エラー時にエラーメッセージを生成
}

fn main() {
    let input = "42";
    match parse_and_multiply(input, 2) {
        Ok(result) => println!("Result: {}", result), // Output: Result: 84
        Err(error) => println!("Error: {}", error),
    }
}

fn filter_and_transform(inputs: Vec<&str>) -> Vec<i32> {
    inputs
        .into_iter()
        .filter_map(|input| input.parse::<i32>().ok()) // 変換に成功した要素だけを保持
        .map(|x| x * 2) // 各要素を2倍
        .collect()
}

fn main() {
    let inputs = vec!["10", "20", "abc", "30"];
    let results = filter_and_transform(inputs);
    println!("{:?}", results); // Output: [20, 40, 60]
}

fn validate_and_divide(input: &str, divisor: i32) -> Result<i32, String> {
    let number = input
        .parse::<i32>()
        .map_err(|_| format!("'{}' is not a valid integer", input))?;

    if divisor == 0 {
        Err("Division by zero is not allowed".to_string())
    } else {
        Ok(number / divisor)
    }
}

fn main() {
    let input = "100";
    match validate_and_divide(input, 5) {
        Ok(result) => println!("Result: {}", result), // Output: Result: 20
        Err(error) => println!("Error: {}", error),
    }
}

fn retry<F, T, E>(mut action: F, retries: u32) -> Result<T, E>
where
    F: FnMut() -> Result<T, E>,
{
    let mut attempts = 0;
    while attempts < retries {
        match action() {
            Ok(result) => return Ok(result),
            Err(_) if attempts < retries - 1 => attempts += 1,
            Err(e) => return Err(e),
        }
    }
    unreachable!()
}

fn main() {
    let mut attempt = 0;
    let result = retry(
        || {
            attempt += 1;
            if attempt < 3 {
                Err("Failed attempt")
            } else {
                Ok("Success")
            }
        },
        5,
    );

    match result {
        Ok(message) => println!("Result: {}", message), // Output: Result: Success
        Err(error) => println!("Error: {}", error),
    }
}

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

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

fn main() {
    match read_file_with_retries("example.txt", 3) {
        Ok(contents) => println!("File contents:\n{}", contents),
        Err(error) => println!("Failed to read file: {}", error),
    }
}

fn mock_http_request() -> Result<String, String> {
    // ダミーのリクエスト処理
    static mut ATTEMPT: u32 = 0;
    unsafe {
        ATTEMPT += 1;
        if ATTEMPT < 3 {
            Err("Temporary network error".to_string())
        } else {
            Ok("Response from server".to_string())
        }
    }
}

fn main() {
    let result = retry(mock_http_request, 5);

    match result {
        Ok(response) => println!("HTTP Response: {}", response), // Output: HTTP Response: Response from server
        Err(error) => println!("Failed to get HTTP response: {}", error),
    }
}

let result = some_operation()
    .map(|x| {
        if x > 0 {
            another_operation(x)
        } else {
            yet_another_operation(x)
        }
    });

let handle_positive = |x| another_operation(x);
let handle_negative = |x| yet_another_operation(x);

let result = some_operation()
    .map(|x| if x > 0 { handle_positive(x) } else { handle_negative(x) });

let handle_error = |e| format!("Error occurred: {}", e);

let result = some_failable_operation().map_err(handle_error);

match result {
    Ok(value) => println!("Success: {}", value),
    Err(message) => println!("{}", message),
}

let result = some_failable_operation()
    .map(|x| x * 2)
    .and_then(|x| another_failable_operation(x))
    .map_err(|e| format!("Error: {}", e));

match result {
    Ok(value) => println!("Final Result: {}", value),
    Err(error) => println!("{}", error),
}

let result = values
    .iter()
    .filter_map(|v| v.parse::<i32>().ok())
    .map(|x| x * 2)
    .collect::<Vec<_>>();

let result = some_failable_operation().map_err(|e| {
    format!("Operation failed due to: {}", e)
});

if let Err(error) = result {
    println!("{}", error);
}

fn retry_with_logging<F, T, E>(mut action: F, retries: u32) -> Result<T, E>
where
    F: FnMut() -> Result<T, E>,
{
    for attempt in 1..=retries {
        match action() {
            Ok(result) => return Ok(result),
            Err(_) if attempt < retries => println!("Retrying... ({}/{})", attempt, retries),
            Err(e) => return Err(e),
        }
    }
    unreachable!()
}

let inputs = vec!["10", "20", "abc", "40"];

// ログ:
"Failed to parse 'abc'"
[20, 40, 80]

fn read_file_with_retry(path: &str) -> Result<String, String> {
    // ここに再試行ロジックを実装してください
}

fn process_input(input: &str) -> Result<i32, String> {
    // 数値変換と割り算処理をここに実装してください
}

// 入力: "10"
"Result: 5"
// 入力: "abc"
"Error: Failed to parse input"
// 入力: "0"
"Error: Division by zero"

fn retry<F, T, E>(action: F, retries: u32) -> Result<T, E>
where
    F: Fn() -> Result<T, E>,
{
    // 再試行ロジックをここに実装してください
}

let result = retry(|| {
    // 再試行対象の処理
    Ok(42)
}, 3);
println!("{:?}", result); // Output: Ok(42)