Rust のクロージャについて

Question

以下にある (例１) は実行可能なのですが、(例２) がコンパイルエラーになる理由が分かりません。
(例２) も、「let mut func」とすればコンパイルが通るのですが、そうすると、逆に (例１) で「mut」が不要な理由が分からなくて悩んでいます。
すみませんが、ご教授くださるよう、どうぞ宜しくお願いいたします。

(例１)

fn main() {
	let str = "string".to_string();
	let mut count = 10;

	let func = || {
		count += 1;
		std::mem::drop(str);
	};

	func();
}

(例２)

fn main() {
	let str = "string".to_string();
	let mut count = 10;

	let func = || {
		count += 1;
//		std::mem::drop(str);
	};

	func();
}

Answer 1

結論から言うと、例1と例2のクロージャが実装しているクロージャトレイトの種類が異なるからです。

• 例1のクロージャ：FnOnceトレイトだけを実装している
• 例2のクロージャ：FnOnceトレイトとFnMutトレイトの両方を実装している

FnMutトレイトを実装するときは、そのクロージャに束縛されている変数（func）にmutキーワードが必要になります。

なぜそうなのか、もう少し詳しく説明しましょう。

クロージャは「無名関数」と「捕捉した環境」からなるデータ構造です。Rustではクロージャを作る構文（|| {..}）は糖衣構文になっており、コンパイラはそれに対して以下を自動生成します。

• 環境を表現するための匿名型（匿名のstruct）
• 環境に対するクロージャトレイトの実装。無名関数はそれらのトレイトが要求するトレイトメソッドとして実装される

匿名型について、たとえば例1のクロージャについて考えてみましょう。

    // 例1のクロージャは`count`と`str`にアクセスする
    let func = || {
        // += 演算子（std::ops::AddAssign）は&mut countを要求する
        count += 1;
        // dropはstrの所有権をとる
        std::mem::drop(str);
    };

この場合、以下のような匿名型が作られます。

struct FuncEnv1<'a> {
    count: &'a mut i32,
    str: String,
}

クロージャトレイトは、無名関数が環境をどう使うかによって、以下の3種類に分けられています。

FnOnceトレイト（ドキュメント）：

• 無名関数を表すcall_once(self, args: Args)メソッドの実装を要求する
• このメソッドの第1引数はselfなので環境の所有権をとる。そのため1回しかコールできない

FnMutトレイト（ドキュメント）：

• 無名関数を表すcall_mut(&mut self, args: Args)メソッドの実装を要求する
• このメソッドの第1引数は&mut selfなので何度でもコールできるが、環境の内容を変更することがある
• FnMutトレイトを実装するには、FnOnceトレイトも実装しなければならない

Fnトレイト（ドキュメント）：

• 無名関数を表すcall(&self, args: Args)メソッドの実装を要求する
• このメソッドの第1引数は&selfなので何度でもコールできる。環境の内容は変更しない
• Fnトレイトを実装するには、FnMutとFnOnceトレイトも実装しなければならない

最初に言ったとおり、例1のクロージャと例2のクロージャでは実装しているトレイトが異なります。

• 例1のクロージャ：FnOnceトレイトだけを実装している
• 例2のクロージャ：FnOnceトレイトとFnMutトレイトの両方を実装している

このことを確認してみましょう。例1を以下のように書き換えます。

// 例1の修正版

// この関数は引数にFnMutを実装するクロージャをとる
fn take_fn_mut(func: &mut impl FnMut()) {
    func();
}

// この関数は引数にFnOnceを実装するクロージャをとる
fn take_fn_once(func: impl FnOnce()) {
    func();
}

fn main() {
    let str = "string".to_string();
    let mut count = 10;

    let func = || {
        count += 1;
        std::mem::drop(str);
    };

    // FnMutではないのでコンパイルできない
    take_fn_mut(&mut func);

    // FnOnceなのでコンパイルできる
    take_fn_once(func);
}

このコードはtake_fn_mut(&mut func);のところで以下のようなコンパイルエラーになります。

$ cargo check
...

error[E0525]: expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
  --> src/bin/main1.rs:17:16
   |
17 |     let func = || {
   |                ^^ this closure implements `FnOnce`, not `FnMut`
18 |         count += 1;
19 |         std::mem::drop(str);
   |                        --- closure is `FnOnce` because it moves the variable `str` out of its environment
...
23 |     take_fn_mut(&mut func);
   |     ----------- the requirement to implement `FnMut` derives from here

エラーの内容

• クロージャがFnMutを実装していることが期待されているが、実際にはFnOnceしか実装していない
• クロージャはFnOnceを実装する（FnMutではない）
• クロージャがFnOnceなのは、変数strを環境（の匿名struct）からメソッド本体にムーブアウトするから

先ほど示したように、例1の匿名型は以下のようになります。

struct MyFuncEnv<'a> {
    count: &'a mut i32,
    str: String,
}

std::mem::dropはself.strの所有権を取るため、無名関数は第1引数にselfを取る必要があります（&mut selfや&selfではだめです）　そのため、このクロージャはcall_once(self, args: Args)の実装を持つFnOnceしか実装できません。

一方、例2のクロージャはFnOnceに加えてFnMutを実装します。そのため以下のように書き換えてもコンパイルエラーになりません。

// 例2の修正版
fn main() {
    let mut count = 10;

    // mutを追加した
    let mut func = || {
        count += 1;
    };

    // どちらもコンパイルできる
    take_fn_mut(&mut func);
    take_fn_once(func);
}

クロージャの本体からstd::mem::dropがなくなったために、所有権を取る必要がなくなり、FnMutが要求するcall_mut(&mut self, args: Args)が実装できるようになったからです。

最後にFnMutだとfuncにmutが必要になる理由ですが、これはクロージャが匿名structであることで説明できます。現時点はnightly版のコンパイラ限定ですが、クロージャのstructとFnMutなどの実装を自分で書くこともできます。それを使うと例2は以下のように実装できます。（cargo +nightly runで実行できます）

// `FnMut`などの実装を提供するには、現時点ではnightly版コンパイラで、
// 以下の実験的なフィーチャをオンにしないといけない
#![feature(fn_traits, unboxed_closures)]

// 例2のクロージャの環境。countの&mut参照を持つ
struct FuncEnv2<'a> {
    count: &'a mut i32,
}

// FnOnceの実装
// FnMutを実装するためには、まずFnOnceを実装しないといけない
impl<'a> FnOnce<()> for FuncEnv2<'a> {
    type Output = ();  // クロージャの戻り値型

    // call_onceを実装する。このメソッドはselfを取る
    extern "rust-call" fn call_once(self, _args: ()) -> Self::Output {
        *self.count += 1;
    }
}

// FnMutの実装
impl<'a> FnMut<()> for FuncEnv2<'a> {
    // call_mutを実装する。このメソッドは&mut selfを取る
    extern "rust-call" fn call_mut(&mut self, _args: ()) -> Self::Output {
        *self.count += 1;
    }
}

// この関数は引数にFnMutを実装するクロージャをとる
fn take_fn_mut(func: &mut impl FnMut()) {
    func();
}

// この関数は引数にFnOnceを実装するクロージャをとる
fn take_fn_once(func: impl FnOnce()) {
    func();
}

fn main() {
    let mut count = 10;

    // funcの実体は環境を表すstruct
    let mut func = FuncEnv2 {
        count: &mut count,
    };

    // FnMutを実装するのでcall_mut(&mut self, ...)を呼ぼうとする
    // &mut self（&mut funcと同じ）をするためにはfuncがmutでないとならない
    func();

    // これらも問題なく呼べる
    take_fn_mut(&mut func);
    take_fn_once(func);
}

func()としたとき、このクロージャはFnMutを実装するために、call_mut(&mut self, ...)メソッドを呼ぼうとします。&mut selfは&mut funcと同じですが、それをするためには、funcがmutの必要があります。

一方、FnOnceの場合はfuncの所有権を取るので、mutは不要になります。その一方で、funcの値はメソッドにムーブしてしまうので、1回しか呼べなくなります。

Comments

[KN2018]

大変丁寧に教えてくださり、本当にありがとうございます。これほどの詳しい解説を書いてくださるために、貴重な時間をどれだけ費やしたかと想像し、本当に感謝の言葉が尽きない思いです。
Rust にとりかかってからまだ数日しか経っておらず、知識が非常に浅い状態でしたので、１行１行から学べることがたくさんあり、知識を深めることができ、大変感謝しております。
実は、さきほどから、どのように感謝の気持ちを表せばよいか悩んでいるのですが、うまく思いつきません、、。平凡な言い方しかできず申し訳ありませんが、本当に本当にありがとうございました。

[tatsuya6502]

疑問が解けたようでよかったです。感謝については普通に「ありがとうございます」で十分ですよ。私は答えを元々知っていたので回答を書くのがすごく大変だったわけではありません。たしかに、適切な例を作るのに試行錯誤があったり、作文の面でそれなりに時間はかかりましたが。

それに、ご質問の内容は、多分、他の多くの人も同じように疑問に持つところだと思います。ですから、こういう形でQ&Aとして残ると他の人にも役立つのではないでしょうか。そう考えると1つの回答の作成に時間をかけても割に合うのかなと考えています。

[KN2018]

温かい言葉を掛けてくださり、大変ありがとうございます。
nightly版のコンパイラを実際に使ってみる貴重な機会ともなりました。nightly版の存在を知っていても、実際に利用してみようという機会はなかなかないと思うので、良い機会を与えてくださり感謝しております。
また、この質問とは別の質問にもご回答してくださり、本当にありがとうございました。