Rustのクロージャを関数の引数として活用する方法を徹底解説

let closure = |x: i32| x + 1;
println!("{}", closure(2)); // 出力: 3

let factor = 2;
let closure = |x: i32| x * factor;
println!("{}", closure(3)); // 出力: 6

fn apply_to_value<F>(x: i32, func: F) -> i32
where
    F: Fn(i32) -> i32,
{
    func(x)
}

fn main() {
    let add_one = |x: i32| x + 1;
    let result = apply_to_value(5, add_one);
    println!("{}", result); // 出力: 6
}

fn apply_fn_once<F>(x: i32, func: F) -> i32
where
    F: FnOnce(i32) -> i32,
{
    func(x)
}

fn call_fn<F>(x: i32, func: F) -> i32
where
    F: Fn(i32) -> i32,
{
    func(x)
}

fn main() {
    let factor = 2;
    let closure = |x| x * factor; // factor を不変参照でキャプチャ
    println!("{}", call_fn(3, closure)); // 出力: 6
}

fn call_fn_mut<F>(x: i32, mut func: F) -> i32
where
    F: FnMut(i32) -> i32,
{
    func(x)
}

fn main() {
    let mut count = 0;
    let mut closure = |x| {
        count += 1; // count を可変参照でキャプチャ
        x + count
    };
    println!("{}", call_fn_mut(5, closure)); // 出力: 6
}

fn call_fn_once<F>(x: i32, func: F) -> i32
where
    F: FnOnce(i32) -> i32,
{
    func(x)
}

fn main() {
    let factor = String::from("Hello");
    let closure = |x| {
        let len = factor.len(); // factor の所有権をクロージャが取得
        x + len as i32
    };
    println!("{}", call_fn_once(3, closure)); // 出力: 8
}

fn apply_operation<F>(x: i32, operation: F) -> i32
where
    F: Fn(i32) -> i32,
{
    operation(x)
}

fn main() {
    let add_two = |x: i32| x + 2; // 数値を2加えるクロージャ
    let square = |x: i32| x * x; // 数値を二乗するクロージャ

    println!("{}", apply_operation(5, add_two)); // 出力: 7
    println!("{}", apply_operation(5, square)); // 出力: 25
}

fn main() {
    let mut count = 0;
    let mut incrementer = |x: i32| {
        count += 1; // 外部の変数 `count` を可変参照でキャプチャ
        x + count
    };

    println!("{}", incrementer(10)); // 出力: 11
    println!("{}", incrementer(10)); // 出力: 12
}

fn filter_list<F>(list: Vec<i32>, predicate: F) -> Vec<i32>
where
    F: Fn(i32) -> bool,
{
    list.into_iter().filter(predicate).collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let is_even = |x: i32| x % 2 == 0; // 偶数を判定するクロージャ

    let even_numbers = filter_list(numbers, is_even);
    println!("{:?}", even_numbers); // 出力: [2, 4, 6]
}

use std::thread;

fn main() {
    let data = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        for num in data {
            println!("{}", num);
        }
    });

    handle.join().unwrap();
}

fn apply_to_all<T, F>(list: Vec<T>, func: F) -> Vec<T>
where
    T: Copy,         // 型Tはコピー可能である必要があります
    F: Fn(T) -> T,   // クロージャは型Tを引数に取り、型Tを返す
{
    list.into_iter().map(func).collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let add_one = |x: i32| x + 1;

    let updated_numbers = apply_to_all(numbers, add_one);
    println!("{:?}", updated_numbers); // 出力: [2, 3, 4, 5, 6]
}

fn conditional_map<T, F1, F2>(list: Vec<T>, condition: F1, action: F2) -> Vec<T>
where
    T: Copy,
    F1: Fn(T) -> bool,  // 条件を評価するクロージャ
    F2: Fn(T) -> T,     // 条件が真の場合に適用するクロージャ
{
    list.into_iter()
        .map(|x| if condition(x) { action(x) } else { x })
        .collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let is_even = |x: i32| x % 2 == 0;
    let double = |x: i32| x * 2;

    let updated_numbers = conditional_map(numbers, is_even, double);
    println!("{:?}", updated_numbers); // 出力: [1, 4, 3, 8, 5]
}

fn combine<T, U, F>(a: T, b: U, func: F) -> String
where
    F: Fn(T, U) -> String,
{
    func(a, b)
}

fn main() {
    let result = combine(5, "times", |x, y| format!("{} {}", x, y));
    println!("{}", result); // 出力: 5 times
}

fn apply_fn<F>(x: i32, func: F) -> i32
where
    F: Fn(i32) -> i32,
{
    func(x)
}

fn main() {
    let add_one = |x: i32| x + 1;
    println!("{}", apply_fn(5, add_one)); // 出力: 6
}

fn create_closure<'a>(value: &'a i32) -> impl Fn() -> i32 + 'a {
    move || *value
}

fn main() {
    let num = 10;
    let closure = create_closure(&num);
    println!("{}", closure()); // 出力: 10
}

fn invalid_closure() -> impl Fn() {
    let value = 10;
    || value
}

fn valid_closure() -> impl Fn() {
    let value = 10;
    move || value
}

fn main() {
    let mut value = 10;
    let closure = || value += 1; // エラー: `value`は不変としてキャプチャされています
    closure();
}

fn main() {
    let mut value = 10;
    let mut closure = || value += 1;
    closure();
    println!("{}", value); // 出力: 11
}

fn main() {
    let value = String::from("Hello");
    let closure = || value; // `value`の所有権がクロージャに移動
    // println!("{}", value); // エラー: `value`は所有権が移動済み
}

fn main() {
    let value = String::from("Hello");
    let closure = || &value;
    println!("{}", closure()); // 出力: Hello
}

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("スレッド内の処理を実行中...");
    });

    handle.join().unwrap(); // スレッドの終了を待機
    println!("メインスレッドの処理が完了しました。");
}

use std::thread;

fn main() {
    let data = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("データ: {:?}", data); // `data`の所有権はスレッド内に移動
    });

    handle.join().unwrap();
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let shared_data = Arc::new(Mutex::new(vec![1, 2, 3]));

    let mut handles = vec![];

    for i in 0..3 {
        let data = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut vec = data.lock().unwrap();
            vec.push(i);
            println!("スレッド {} がデータを追加しました: {:?}", i, vec);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("最終的なデータ: {:?}", *shared_data.lock().unwrap());
}

use std::thread;

fn main() {
    let handle = thread::spawn(|| -> Result<(), String> {
        Err("スレッド内でエラーが発生しました".to_string())
    });

    match handle.join() {
        Ok(result) => match result {
            Ok(_) => println!("スレッドが正常に終了しました。"),
            Err(e) => println!("スレッド内のエラー: {}", e),
        },
        Err(_) => println!("スレッドのパニックを検出しました。"),
    }
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // クロージャを使った変換
    let squared_numbers: Vec<_> = numbers.iter().map(|x| x * x).collect();
    println!("二乗した数値: {:?}", squared_numbers); // 出力: [1, 4, 9, 16, 25]

    // クロージャを使ったフィルタリング
    let even_numbers: Vec<_> = numbers.iter().filter(|x| *x % 2 == 0).collect();
    println!("偶数のみ: {:?}", even_numbers); // 出力: [2, 4]
}

fn main() {
    let values = vec![Some(1), None, Some(3)];

    let filtered_values: Vec<_> = values
        .into_iter()
        .filter_map(|x| match x {
            Some(v) if v % 2 == 0 => Some(v), // 偶数のみをフィルタリング
            _ => None,
        })
        .collect();

    println!("フィルタリング結果: {:?}", filtered_values); // 出力: []
}

fn main() {
    let parse_numbers = vec!["42", "invalid", "100"]
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect::<Vec<_>>();

    println!("パース成功: {:?}", parse_numbers); // 出力: [42, 100]
}

struct Processor<T> {
    process: Box<dyn Fn(T) -> T>,
}

impl<T> Processor<T> {
    fn new<F>(func: F) -> Self
    where
        F: Fn(T) -> T + 'static,
    {
        Processor {
            process: Box::new(func),
        }
    }

    fn execute(&self, value: T) -> T {
        (self.process)(value)
    }
}

fn main() {
    let doubler = Processor::new(|x: i32| x * 2);
    println!("結果: {}", doubler.execute(5)); // 出力: 10
}

fn transform_list<F>(list: Vec<i32>, func: F) -> Vec<i32>
where
    F: Fn(i32) -> i32,
{
    // 実装を記述
}

let numbers = vec![1, 2, 3, 4];
let doubled = transform_list(numbers, |x| x * 2);
println!("{:?}", doubled); // 出力: [2, 4, 6, 8]

let numbers = vec![1, 2, 3, 4, 5, 6];
let even_numbers = filter_even(numbers, |x| x % 2 == 0);
println!("{:?}", even_numbers); // 出力: [2, 4, 6]

let numbers = vec![1, 2, 3, 4, 5];
let processed = process_with_condition(numbers, |x| x % 2 == 0);
println!("{:?}", processed); // 出力: [1, 4, 3, 8, 5]

スレッドで計算中...
結果: 25