Rustでクロージャを所有権として渡すべき場合と借用すべき場合の判断基準を徹底解説

let x = 10;
let closure = || println!("x: {}", x);
closure(); // ここでは`x`が借用されている

let mut x = 10;
let mut closure = || x += 5;
closure();
println!("x: {}", x); // 15

let x = String::from("Hello");
let closure = move || println!("x: {}", x);
// ここで`x`の所有権はクロージャに移動している
closure();

let x = 10;
let closure = || println!("x: {}", x); // 借用キャプチャ
closure(); // xの所有権は移動しない
println!("x is still accessible: {}", x);

let mut x = 5;
let mut closure = || x += 1; // 可変借用キャプチャ
closure();
println!("x after closure: {}", x); // 6

let x = String::from("Rust");
let closure = move || println!("x: {}", x); // 所有権キャプチャ
closure();
// println!("x: {}", x); // エラー: xは所有権を失った

let x = vec![1, 2, 3];
let closure = move || println!("x: {:?}", x); // xの所有権を奪う
closure();
// println!("{:?}", x); // エラー

let x = 42;
let print_closure = || println!("Value of x: {}", x); // 借用キャプチャ
print_closure();
println!("x is still accessible: {}", x); // 借用なので利用可能

let data = vec![1, 2, 3];
let closure = || println!("Data: {:?}", data); // 不変借用
let another_closure = || println!("Also accessing data: {:?}", data); // 他の借用も可能
closure();
another_closure();

let large_data = vec![0; 1_000_000]; // 大量のデータ
let process_closure = || println!("Processing data of size: {}", large_data.len()); // 借用で効率化
process_closure();

use std::sync::Arc;

let shared_data = Arc::new(vec![1, 2, 3]);
let data_ref = Arc::clone(&shared_data);
let closure = move || println!("Shared data: {:?}", data_ref); // Arcによる共有と借用
closure();

let config = "Rust Configuration";
let show_config = || println!("Current config: {}", config); // 不変借用
show_config();
println!("Config still accessible: {}", config);

use std::thread;

let message = String::from("Hello, world!");
let closure = move || println!("{}", message); // 所有権をクロージャに移動
thread::spawn(closure).join().unwrap();
// println!("{}", message); // エラー: messageは所有権を失った

let temp_data = vec![1, 2, 3];
let closure = move || println!("Temporary data: {:?}", temp_data); // 所有権を移動
closure();
// println!("{:?}", temp_data); // エラー: temp_dataは所有権を失った

let data = vec![0; 1_000_000]; // 大きなデータ
let closure = move || println!("Processing large data of size: {}", data.len()); // 所有権を移動して効率化
closure();

let message = String::from("Goodbye!");
let closure = move || println!("{}", message); // 所有権を移動
closure(); // messageの所有権はクロージャ内で完結

let config = String::from("Configuration");
let closure = move || println!("Using config: {}", config); // 所有権を移動
closure();
// println!("{}", config); // エラー: configは所有権を失った

let x = vec![1, 2, 3];
let closure = move || println!("{:?}", x); // moveが必要
closure();

fn main() {
    let greeting = String::from("Hello, Rust!");
    let print_closure = || println!("{}", greeting); // 借用キャプチャ
    print_closure(); // greetingを表示
    println!("Greeting is still accessible: {}", greeting); // 借用なので利用可能
}

fn main() {
    let mut count = 0;
    let mut increment = || count += 1; // 可変借用キャプチャ
    increment(); // countを1増やす
    println!("Updated count: {}", count); // 借用が解放されたので利用可能
}

fn main() {
    let message = String::from("Ownership moved!");
    let print_closure = move || println!("{}", message); // 所有権キャプチャ
    print_closure();
    // println!("{}", message); // エラー: messageの所有権は移動済み
}

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

    // 借用キャプチャ
    let borrow_closure = || println!("Borrowed data: {:?}", data);
    borrow_closure();
    println!("Data is still accessible: {:?}", data);

    // 所有権キャプチャ
    let own_closure = move || println!("Owned data: {:?}", data);
    own_closure();
    // println!("Data is no longer accessible: {:?}", data); // エラー: 所有権が移動
}

use std::thread;

fn main() {
    let shared_data = String::from("Shared across threads");

    // 所有権キャプチャを使ってスレッドにデータを渡す
    let thread_handle = thread::spawn(move || {
        println!("Thread data: {}", shared_data);
    });

    thread_handle.join().unwrap();
}

fn main() {
    let large_data = vec![0; 1_000_000]; // 大きなデータ
    let closure = || println!("Data length: {}", large_data.len()); // 借用
    closure(); // データのコピーは発生しない
}

let data = String::from("Shared data");
let borrow_closure = || println!("Accessing: {}", data);
borrow_closure();
println!("Still accessible: {}", data);

use std::thread;

fn main() {
    let large_data = vec![0; 1_000_000]; // 大きなデータ
    let closure = move || println!("Owned data length: {}", large_data.len()); // 所有権移動
    thread::spawn(closure).join().unwrap();
}

fn main() {
    let data = String::from("Process this data");

    // 借用を使用したエラーハンドリング
    let process = || -> Result<(), &'static str> {
        if data.is_empty() {
            Err("Data is empty")
        } else {
            println!("Processing: {}", data);
            Ok(())
        }
    };

    if let Err(e) = process() {
        println!("Error occurred: {}", e);
    }
    // クロージャの後もdataは利用可能
    println!("Data is still accessible: {}", data);
}

fn main() {
    let data = String::from("Ownership move example");

    // 所有権を移動してエラーハンドリング
    let process = move || -> Result<(), &'static str> {
        if data.is_empty() {
            Err("Data is empty")
        } else {
            println!("Processing: {}", data);
            Ok(())
        }
    };

    if let Err(e) = process() {
        println!("Error occurred: {}", e);
    }
    // println!("Data is accessible: {}", data); // エラー: dataは所有権を失った
}

fn main() {
    let divide = |numerator: f64, denominator: f64| -> Result<f64, &'static str> {
        if denominator == 0.0 {
            Err("Division by zero")
        } else {
            Ok(numerator / denominator)
        }
    };

    match divide(10.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

use std::fs::File;
use std::io::Read;

fn main() {
    let file_name = String::from("example.txt");

    let read_file = move || -> Result<String, std::io::Error> {
        let mut file = File::open(&file_name)?;
        let mut content = String::new();
        file.read_to_string(&mut content)?;
        Ok(content)
    };

    match read_file() {
        Ok(content) => println!("File content:\n{}", content),
        Err(e) => println!("Failed to read file: {}", e),
    }
}

use std::thread;

fn main() {
    let data = String::from("Thread-safe data");

    let handle = thread::spawn(move || {
        // 所有権を移動して安全に処理
        println!("Processing data in thread: {}", data);
    });

    handle.join().unwrap();
    // println!("{}", data); // エラー: 所有権は移動済み
}

use std::sync::{Arc, Mutex};
use warp::Filter;

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

    let data_filter = warp::any()
        .map(move || {
            let data = shared_data.lock().unwrap(); // 借用キャプチャでリソースにアクセス
            format!("Current data: {:?}", *data)
        });

    warp::serve(data_filter).run(([127, 0, 0, 1], 3030));
}

use tokio::task;

#[tokio::main]
async fn main() {
    let data = String::from("Async data processing");

    let task = task::spawn(async move {
        // 所有権を移動して非同期タスク内で処理
        println!("Processing data: {}", data);
    });

    task.await.unwrap();
    // println!("{}", data); // エラー: 所有権はタスクに移動済み
}

use std::collections::HashMap;

fn main() {
    let mut cache: HashMap<i32, i32> = HashMap::new();

    let mut get_or_compute = |key: i32| -> i32 {
        *cache.entry(key).or_insert_with(|| {
            println!("Computing for key: {}", key);
            key * key
        })
    };

    println!("Value: {}", get_or_compute(2)); // 計算される
    println!("Value: {}", get_or_compute(2)); // キャッシュされている
}

fn execute_query<F>(query: F)
where
    F: FnOnce() -> Result<String, &'static str>,
{
    match query() {
        Ok(result) => println!("Query successful: {}", result),
        Err(e) => println!("Query failed: {}", e),
    }
}

fn main() {
    let database = "SimulatedDatabase";
    execute_query(|| {
        if database == "SimulatedDatabase" {
            Ok("Query Result: Success".to_string())
        } else {
            Err("Database connection failed")
        }
    });
}