Rustの標準ライブラリにおけるクロージャの使い方と設計例

let add = |x: i32, y: i32| x + y;
let result = add(2, 3);
println!("結果: {}", result); // 結果: 5

let x = 10;
let closure = || println!("x: {}", x); // xを借用する
closure();

let multiply = |a, b| a * b;
let result = multiply(3, 4); // コンパイラが型を推論
println!("結果: {}", result); // 結果: 12

fn use_closure<F>(closure: F) 
where
    F: Fn(),
{
    closure();
}

let x = 5;
let print_x = || println!("x: {}", x); // 環境を参照
use_closure(print_x);

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

let numbers = vec![1, 2, 3, 4, 5];

// フィルタリング: 偶数だけを抽出
let even_numbers: Vec<i32> = numbers.into_iter().filter(|&x| x % 2 == 0).collect();
println!("{:?}", even_numbers); // [2, 4]

// マッピング: 各要素を2倍
let doubled_numbers: Vec<i32> = numbers.into_iter().map(|x| x * 2).collect();
println!("{:?}", doubled_numbers); // [2, 4, 6, 8, 10]

use std::thread;

let handle = thread::spawn(|| {
    println!("スレッドでの処理中...");
});
handle.join().unwrap();

let mut count = 0;
let mut increment = || {
    count += 1;
    println!("カウント: {}", count);
};

increment(); // カウント: 1
increment(); // カウント: 2

let result: Result<i32, &str> = Ok(10);
let doubled = result.map(|x| x * 2);
println!("{:?}", doubled); // Ok(20)

use futures::executor::block_on;

async fn example() -> i32 {
    42
}

let future = example().map(|x| x + 1);
let result = block_on(future);
println!("結果: {}", result); // 結果: 43

let numbers = vec![1, 2, 3, 4, 5];

// 各要素を2倍にする
let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
println!("{:?}", doubled); // [2, 4, 6, 8, 10]

// 偶数のみを抽出
let evens: Vec<i32> = numbers.into_iter().filter(|x| x % 2 == 0).collect();
println!("{:?}", evens); // [2, 4]

let numbers = vec![1, 2, 3, 4, 5, 6];

// 奇数を抽出し、各値を3倍にして合計を計算
let result: i32 = numbers
    .into_iter()
    .filter(|x| x % 2 != 0) // 奇数のみ
    .map(|x| x * 3)        // 各値を3倍
    .sum();                // 合計
println!("結果: {}", result); // 結果: 27

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count <= 5 {
            Some(self.count)
        } else {
            None
        }
    }
}

let result: u32 = Counter::new()
    .map(|x| x * 2) // 各要素を2倍
    .filter(|x| x % 3 == 0) // 3で割り切れるものを抽出
    .sum(); // 合計
println!("結果: {}", result); // 結果: 12

let numbers = 1..=1_000_000;

// 合計を計算
let sum: u64 = numbers
    .filter(|x| x % 2 == 0) // 偶数のみ
    .map(|x| x * 2)         // 各値を2倍
    .sum();
println!("合計: {}", sum);

let x = 10;
let print_x = || println!("x: {}", x); // xを借用
print_x();

let mut count = 0;
let mut increment = || {
    count += 1; // countを可変借用
    println!("カウント: {}", count);
};
increment();
increment();

let name = String::from("Rust");
let consume = || {
    println!("名前: {}", name);
}; // nameの所有権を取得
consume();
// println!("{}", name); // エラー: 所有権が移動済み

fn create_closure() -> impl Fn() {
    let x = 10;
    move || println!("x: {}", x) // xの所有権を移動
}
let closure = create_closure();
closure();

fn main() {
    let x = String::from("Rust");
    let closure = || println!("{}", x); // xを借用
    drop(x); // 所有権を破棄
    closure(); // エラー: xはすでに破棄されている
}

fn main() {
    let x = String::from("Rust");
    let closure = move || println!("{}", x); // xを移動
    closure(); // 問題なく動作
}

fn apply_to_value<F>(f: F, value: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(value)
}

let square = |x| x * x;
let result = apply_to_value(square, 5);
println!("結果: {}", result); // 結果: 25

fn call_fn<F: Fn()>(f: F) {
    f();
}

fn call_fn_mut<F: FnMut()>(mut f: F) {
    f();
}

fn call_fn_once<F: FnOnce()>(f: F) {
    f();
}

let name = String::from("Rust");

call_fn(|| println!("参照: {}", name)); // 借用
call_fn_mut(|| println!("可変参照: {}", name)); // 可変借用
call_fn_once(|| println!("所有権: {}", name)); // 所有権を取得

fn chain_operations<F1, F2>(f1: F1, f2: F2, value: i32) -> i32
where
    F1: Fn(i32) -> i32,
    F2: Fn(i32) -> i32,
{
    f2(f1(value))
}

let add_one = |x| x + 1;
let double = |x| x * 2;

let result = chain_operations(add_one, double, 5);
println!("結果: {}", result); // 結果: 12

fn handle_event<F>(event_handler: F)
where
    F: Fn(&str),
{
    let event = "click";
    event_handler(event);
}

handle_event(|event| println!("イベント: {}", event));

use tokio::runtime::Runtime;

fn execute_async<F>(task: F)
where
    F: FnOnce(),
{
    let rt = Runtime::new().unwrap();
    rt.block_on(async { task() });
}

execute_async(|| println!("非同期タスクの実行中"));

fn parse_number(input: &str) -> Result<i32, String> {
    input.parse::<i32>().map_err(|_| format!("'{}' は数値ではありません", input))
}

fn main() {
    let result = parse_number("42");
    match result {
        Ok(num) => println!("数値: {}", num),
        Err(e) => println!("エラー: {}", e),
    }

    let result = parse_number("abc");
    match result {
        Ok(num) => println!("数値: {}", num),
        Err(e) => println!("エラー: {}", e),
    }
}

fn validate_input(input: &str) -> Result<i32, String> {
    input
        .parse::<i32>()
        .map_err(|_| format!("'{}' は数値ではありません", input))
        .and_then(|num| {
            if num >= 0 {
                Ok(num)
            } else {
                Err("負の値は無効です".to_string())
            }
        })
}

fn main() {
    match validate_input("-42") {
        Ok(num) => println!("有効な数値: {}", num),
        Err(e) => println!("エラー: {}", e),
    }
}

fn fetch_number(input: Option<&str>) -> i32 {
    input
        .and_then(|s| s.parse::<i32>().ok())
        .unwrap_or_else(|| {
            println!("デフォルト値を使用します");
            0
        })
}

fn main() {
    let number = fetch_number(Some("42"));
    println!("結果: {}", number); // 結果: 42

    let number = fetch_number(None);
    println!("結果: {}", number); // 結果: 0
}

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

fn read_file_content(path: &str) -> Result<String, io::Error> {
    File::open(path)
        .and_then(|mut file| {
            let mut content = String::new();
            file.read_to_string(&mut content)?;
            Ok(content)
        })
        .map_err(|e| {
            eprintln!("エラー: {:?}", e);
            e
        })
}

fn main() {
    match read_file_content("example.txt") {
        Ok(content) => println!("ファイル内容: {}", content),
        Err(_) => println!("ファイルを読み込めませんでした"),
    }
}

fn apply_strategy<F>(value: i32, strategy: F) -> i32
where
    F: Fn(i32) -> i32,
{
    strategy(value)
}

fn main() {
    let add_one = |x| x + 1;
    let multiply_by_two = |x| x * 2;

    let result1 = apply_strategy(5, add_one);
    let result2 = apply_strategy(5, multiply_by_two);

    println!("結果1: {}", result1); // 結果1: 6
    println!("結果2: {}", result2); // 結果2: 10
}

use std::collections::VecDeque;

fn main() {
    let mut commands: VecDeque<Box<dyn Fn()>> = VecDeque::new();

    commands.push_back(Box::new(|| println!("コマンド1を実行")));
    commands.push_back(Box::new(|| println!("コマンド2を実行")));
    commands.push_back(Box::new(|| println!("コマンド3を実行")));

    while let Some(command) = commands.pop_front() {
        command();
    }
}

fn log_decorator<F>(func: F) -> impl Fn(i32) -> i32
where
    F: Fn(i32) -> i32,
{
    move |x| {
        println!("入力値: {}", x);
        let result = func(x);
        println!("結果: {}", result);
        result
    }
}

fn main() {
    let multiply_by_two = |x| x * 2;
    let decorated = log_decorator(multiply_by_two);

    let result = decorated(5); // 入力値: 5 結果: 10
    println!("最終結果: {}", result);
}

fn factory(is_large: bool) -> Box<dyn Fn() -> String> {
    if is_large {
        Box::new(|| "大きなオブジェクトを生成".to_string())
    } else {
        Box::new(|| "小さなオブジェクトを生成".to_string())
    }
}

fn main() {
    let create_large = factory(true);
    let create_small = factory(false);

    println!("{}", create_large()); // 大きなオブジェクトを生成
    println!("{}", create_small()); // 小さなオブジェクトを生成
}

fn main() {
    let mut state: Box<dyn Fn() -> String> = Box::new(|| "状態1".to_string());

    println!("{}", state());

    state = Box::new(|| "状態2".to_string());
    println!("{}", state());
}