## Rust クロージャの理解 クロージャは、周囲の環境から変数を捕捉する匿名関数です。 型安全性を保ちつつ、コールバックやインラインロジックを書きやすくします。 ### 主な概念 - **キャプチャモード** - `&T`：不変参照で借用（`Fn`） - `&mut T`：可変参照で借用（`FnMut`） - `T`：所有権を移動（`FnOnce`） - **実装されるトレイト** - `Fn`：変更なしに複数回呼び出せる。 - `FnMut`：可変状態の変更が許容される。 - `FnOnce`：捕捉した値を消費し、1 回だけ使用できる。 ### 構文 ```rust let x = 5; let closure = |y: i32| x + y; // `x` を不変参照で捕捉 ``` - パラメータと戻り値の型は推論されます。 - 明示的に型を書くこともできますが、必須ではありません。 ### よく使われる場面 - **イテレータ** – `map`・`filter`・`fold` など。 - **コールバック** – イベント処理や非同期タスク。 - **遅延評価** – 必要になってから計算を行う。 ### パフォーマンスの考慮点 - クロージャはゼロコスト抽象化であり、可能な限りインラインコードに変換されます。 - 大きな構造体を参照で捕捉すると不要なコピーを避けられます。 ### 例：ベクタのフィルタリング ```rust let numbers = vec![1, 2, 3, 4, 5]; let evens: Vec<i32> = numbers.into_iter() .filter(|n| n % 2 == 0) .collect(); ``` クロージャ `|n| n % 2 == 0` は何も捕捉せず、`FnMut` を実装しています。 ### 要約 - クロージャを使えば簡潔で再利用可能なコードを書けます。 - キャプチャモードを理解することで正しい所有権の挙動が保証されます。 - 適切に `Fn`・`FnMut`・`FnOnce` を選択すればパフォーマンスも最適化できます。 クロージャをマスターすれば、Rust で関数型スタイルのプログラミングを強力に行うことが可能になります。

閉包（Closure）の基礎

既に知っていると思いますが、Rust で閉包は次のような構文で書く関数です。

let double_closure = |x| x * 2;
assert_eq!(4, double_closure(2));

通常の関数として書くとこうなります。

fn double_function(x: u32) -> u32 {
    x * 2
}
assert_eq!(4, double_function(2));

ほぼ同じです。違いは

double_function

u32

i32

let double_typed_closure = |x: u32| -> u32 { x * 2 };
assert_eq!(4, double_typed_closure(2));
assert_eq!(4, double_typed_closure(2u32));
// assert_eq!(4, double_typed_closure(2u16)); // ← エラーになります。

閉包を使う典型例として

Option::map

assert_eq!(Some(4), Some(2).map(|x| x * 2));
assert_eq!(Some(4), Some(2).map(double_closure)); // 上で定義した double_closure
assert_eq!(Some(4), Some(2).map(double_function)); // 関数も同様に使えます。

つまり、閉包は型推論を利用して関数を書きやすくした構文糖です。

変数の取得（Capture）

閉包と関数の主な違いは、閉包がその環境から変数を取得できる点にあります。関数はそうではありません。

let hello = "Hello ";
let greeter_closure = |x| String::new() + hello + x;

assert_eq!("Hello world", greeter_closure("world"));
assert_eq!(
    Some("Hello world".to_owned()),
    Some("world").map(greeter_closure)
);

greeter_closure

hello

let hello = "Hello ";

fn greeter_function(x: &str) -> String {
    String::new() + hello + x
}

コンパイラは次のように言います。

error[E0434]: can't capture dynamic environment in a fn item
 --> src/main.rs:7:25
  |
7 |         String::new() + hello + x
  |                         ^^^^^
  |
  = help: use the `|| { ... }` closure form instead

共有参照での取得

上記の

greeter_closure

hello

&'a str

hello

let hello = "Hello ";
let greeter_closure = |x| String::new() + hello + x;

// まだ使用可能
assert_eq!("Hello ", hello);

assert_eq!("Hello world", greeter_closure("world"));

// 再び
assert_eq!("Hello ", hello);

可変参照での取得

可変参照を使って閉包が捕捉した値を書き換えることもできます。

let mut total = 0;
let add_mut_closure = |x| total += x;

// ここでは `total` にアクセスできません
// assert_eq!(0, total);
// error[E0502]: cannot borrow `total` as immutable because it is also borrowed as mutable

(1..=10).for_each(add_mut_closure);

// 今度は参照可能です
assert_eq!(55, total);

値での取得（Move）

最後に値を取得する例です。

let last_word = "last word: ".to_owned();
let drop_closure = |sigh| {
    let res = String::new() + &last_word + sigh;
    drop(last_word); // これで値として取得
    res
};

// ここでは `last_word` にアクセスできません
// assert_eq!("last word: ".to_owned(), last_word);
// error[E0382]: borrow of moved value: `last_word`

assert_eq!("last word: sigh!", drop_closure("sigh!"));

// 再度呼び出すことはできません
// assert_eq!("last word: sigh!", drop_closure("sigh!"));
// error[E0382]: use of moved value: `drop_closure`

FnOnce トレイト

前述の例で、

drop_closure

note: closure cannot be invoked more than once because it moves the variable `last_word` out of its environment

これは閉包が実装する

FnOnce

FnOnce

FnOnce

閉包のデシグナリング

nightly と以下の機能を有効化すると、

drop_closure

#![feature(fn_traits)]
#![feature(unboxed_closures)]

struct DropStruct {
    last_word: String,
}

impl FnOnce<(&str,)> for DropStruct {
    type Output = String;
    extern "rust-call" fn call_once(self, (sigh,): (&str,)) -> Self::Output {
        let res = String::new() + &self.last_word + sigh;
        drop(self.last_word);
        res
    }
}

使い方は次の通りです。

let last_word = "last word: ".to_owned();
let drop_struct = DropStruct { last_word };

assert_eq!("last word: sigh!", drop_struct("sigh!"));
// 二度呼び出すとエラーになります。
// drop_struct("sigh!");

FnMut トレイト

変数を変更する閉包は

FnMut

let mut v = vec![];
let push_closure = |x| v.push(x);

(1..=5).for_each(push_closure);
assert_eq!(vec![1, 2, 3, 4, 5], v);

デシグナリングすると次のようになります。

struct PusherStruct<'a> {
    v: &'a mut Vec<i32>,
}

impl<'a> FnMut<(i32,)> for PusherStruct<'a> {
    extern "rust-call" fn call_mut(&mut self, (x,): (i32,)) -> Self::Output {
        self.v.push(x)
    }
}

FnOnce

impl<'a> FnOnce<(i32,)> for PusherStruct<'a> {
    type Output = ();
    extern "rust-call" fn call_once(mut self, args: (i32,)) -> Self::Output {
        self.call_mut(args)
    }
}

Fn トレイト

複数回呼び出せ、可変参照を必要としない閉包は

Fn

greeter_closure

let hello = "Hello ";
let greeter_closure = |x| String::new() + hello + x;

assert_eq!("Hello world", greeter_closure("world"));
assert_eq!("Hello rust", greeter_closure("rust")); // 何度でも呼び出せる

構造体とトレイト実装に変換すると次のようになります。

struct GreeterStruct<'a> {
    hello: &'a str,
}

impl<'a, 'b> FnOnce<(&'b str,)> for GreeterStruct<'a> {
    type Output = String;
    extern "rust-call" fn call_once(self, args: (&'b str,)) -> Self::Output {
        self.call(args)
    }
}
impl<'a, 'b> FnMut<(&'b str,)> for GreeterStruct<'a> {
    extern "rust-call" fn call_mut(&mut self, args: (&'b str,)) -> Self::Output {
        self.call(args)
    }
}
impl<'a, 'b> Fn<(&'b str,)> for GreeterStruct<'b> {
    extern "rust-call" fn call(&self, (x,): (&'b str,)) -> Self::Output {
        String::new() + &self.hello + &x
    }
}

使い方は次の通りです。

let hello = "Hello";
let greeter_struct = GreeterStruct { hello };

assert_eq!("Hello world", greeter_struct("world"));
assert_eq!("Hello rust", greeter_struct("rust")); // 何度でも呼び出せる

move

キーワード

move

let hello = "Hello ".to_owned();
let greeter_closure = move |x| String::new() + &hello + x;

// ここでは `hello` にアクセスできません
// assert_eq!("Hello ", hello);
// error[E0382]: borrow of moved value: `hello`

assert_eq!("Hello world", greeter_closure("world"));

異なるキャプチャモードの理解

以下のダミー関数を定義します。

fn by_ref(_data: &String) {}
fn by_mut(_data: &mut String) {}
fn by_value(_data: String) {}

次に

move

by_ref

by_mut

by_value

move by_ref

move by_mut

move by_value

move

デシグナリング例

move

を使わない場合

struct ByRefStruct<'a> {
    data: &'a String,
}

impl<'a> FnOnce<()> for ByRefStruct<'a> {
    type Output = ();
    extern "rust-call" fn call_once(self, args: ()) -> Self::Output { self.call(args) }
}
impl<'a> FnMut<()> for ByRefStruct<'a> {
    extern "rust-call" fn call_mut(&mut self, args: ()) -> Self::Output { self.call(args) }
}
impl<'a> Fn<()> for ByRefStruct<'a> {
    extern "rust-call" fn call(&self, (): ()) -> Self::Output { by_ref(self.data) }
}

move

を使う場合

struct MoveByRefStruct {
    data: String,
}

impl FnOnce<()> for MoveByRefStruct {
    type Output = ();
    extern "rust-call" fn call_once(self, args: ()) -> Self::Output { self.call(args) }
}
impl FnMut<()> for MoveByRefStruct {
    extern "rust-call" fn call_mut(&mut self, args: ()) -> Self::Output { self.call(args) }
}
impl Fn<()> for MoveByRefStruct {
    extern "rust-call" fn call(&self, (): ()) -> Self::Output { by_ref(&self.data) }
}

data

&'a String

String

by_ref

&self.data

実用例

スレッドを生成する場合

let data = "by_ref".to_owned();
std::thread::spawn(|| by_ref(&data)).join().unwrap(); // エラー: borrow may outlive current function

move

std::thread::spawn(move || by_ref(&data)).join().unwrap();

関数から閉包を返す場合

fn make_greeter(greeter: &str) -> impl Fn(&str) -> String {
    move |name| format!("{greeter} {name}")
}

let hello_greeter = make_greeter("Hello");
assert_eq!(hello_greeter("rust"), "Hello rust");

move

greeter

まとめ

この記事はこれで終わります。後日 async 閉包についての追記事項を公開予定です。

さらに学びたい方には以下をおすすめします：

• Rust 本の closures チャプター
• Rust リファレンスの closures チャプター
• Baby Steps ブログの「explicit capture clause」記事

• fn_traits

  と

  unboxed_closures

  を扱う Rust Unstable Book

ご清聴ありがとうございました。