Rust勉強中 - その20 -> クロージャ

# 自己紹介
出田 守と申します。
しがないPythonプログラマです。
情報セキュリティに興味があり現在勉強中です。CTFやバグバウンティなどで腕を磨いています。主に低レイヤの技術が好きで、そっちばかり目が行きがちです。

Rustを勉強していくうえで、読んで学び、手を動かし、記録し、楽しく学んでいけたらと思います。

# 環境
新しい言語を学ぶということで、普段使わないWindowsとVimという新しい開発環境で行っています。
OS: Windows10 Home 64bit 1903
CPU: Intel Core i5-3470 @ 3.20GHz
Rust: 1.38.0
RAM: 8.00GB
Editor: Vim 8.1.1
Terminal: PowerShell

# 前回
前回はユーティリティトレイトについて学びました。
[Rust勉強中 - その19](https://qiita.com/deta-mamoru/items/62f5edebb359d7acd563)

# クロージャ
Rustのクロージャは他の言語でいう無名関数式やlambda式です。
ただし、Rustのクロージャは高速で安全です。

## クロージャのフォーマット
クロージャの書き方は以下のように書けます。
クロージャは引数や戻り値の型が自明であれば省略できます。

```Rust
|arg: T| -> T {
    expr_1;
    ...
    expr_n
};
```
以下に例を示します。

```Rust
fn main() {
    let c1 = |x| x+1;
    println!("{}", c1(10)); // 11
}
```
変数c1はクロージャを格納する変数です。クロージャには引数や戻り値の型を省略して書いています。また、`{}`も複数行の式でなければ省略できます。

## クロージャにおける変数の移動と借用
クロージャは以下のように、クロージャ外の変数を参照することができます。

```Rust
fn main() {
    ...
    let x = 1;
    let c1 = || println!("{}", x);
    c1(); // 1
}
```
変数xはクロージャを定義する前に、先に定義されています。その変数xをクロージャ内で参照し表示しました。クロージャはこの変数xの借用することができます。
もし、所有権を移動させたい場合は、`move`を用います。

```Rust
move |arg| expr;
```
混乱しそうだったので、クロージャでmoveありなしの動作を以下のようにして確認しました。もしかして、引数もmoveありなしで変わるのか？という疑問があったので引数についても確認しました。
まず、moveなしで引数に参照を渡した場合を確認します。

```Rust
fn main() {
    ...
    let num = vec![5];
    let arg = vec![6];
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
    let c2 = |arg| {
        println!("num: {:p}", &num);
        println!("arg: {:p}", arg);
    };
    c2(&arg);
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
```
```
num: 0xd2186ff348
arg: 0xd2186ff360
num: 0xd2186ff348
arg: 0xd2186ff360
num: 0xd2186ff348
arg: 0xd2186ff360
```
変数numは外部変数で、argが引数です。変数numと引数argのアドレスは変わりません。つまり借用されていることが分かります。

次にmoveなしで引数に値を渡した場合を確認します。

```Rust
fn main() {
    ...
    let num = vec![5];
    let arg = vec![6];
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
    let c2 = |arg| {
        println!("num: {:p}", &num);
        println!("arg: {:p}", &arg);
    };
    c2(arg);
    println!("num: {:p}", &num);
    // println!("arg: {:p}", &arg); // Error
```
```
num: 0xe2ec7ef278
arg: 0xe2ec7ef290
num: 0xe2ec7ef278
arg: 0xe2ec7ef350
num: 0xe2ec7ef278
```
変数numは先ほどと同じでアドレスが変わらずです。argに関しては所有権の移動が発生するのでアドレスが変わっています。

次にmoveありで引数に参照を渡した場合を確認します。

```Rust
fn main() {
    ...
    let num = vec![5];
    let arg = vec![6];
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
    let c2 = move |arg| {
        println!("num: {:p}", &num);
        println!("arg: {:p}", arg);
    };
    c2(&arg);
    // println!("num: {:p}", &num); // Error
    println!("arg: {:p}", &arg);
}
```
```
num: 0x2368d7f540
arg: 0x2368d7f558
num: 0x2368d7f610
arg: 0x2368d7f558
arg: 0x2368d7f558
```
moveありだと、変数numは所有権の移動が発生するのでアドレスが変化しています。引数argは参照を渡しているのでアドレスに変化はありません。

最後にmoveありの引数に値を渡した場合を確認します。

```Rust
fn main() {
    let c0 = |x| x+1;
    println!("{}", c0(10));
    // move or not
    let x = 1;
    let c1 = || println!("{}", x);
    c1();
    let num = vec![5];
    let arg = vec![6];
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
    let c2 = move |arg| {
        println!("num: {:p}", &num);
        println!("arg: {:p}", &arg);
    };
    c2(arg);
    // println!("num: {:p}", &num);
    // println!("arg: {:p}", &arg);
```
```
num: 0xed5c3ff630
arg: 0xed5c3ff648
num: 0xed5c3ff700
arg: 0xed5c3ff720
```
この場合はどちらもアドレスに変化があり、所有権の移動が発生しています。

ダラダラと恐れ入ります。
以上をまとめますと、moveありなしで所有権の移動、借用が変化するのはクロージャ外の変数のみで、引数は関係ありませんでした。

移動が発生したときにその値がコピー可能であればコピーされますので、その後も変数を使用できます。

## クロージャのトレイト
クロージャは以下のいずれかのトレイトを実装することになります。

```Rust
trait Fn<Args> : FnMut<Args> {
    fn call(&self, args: Args) -> Self::Output;
}
```
```Rust
trait FnMut<Args> : FnOnce<Args> {
    fn call_mut(&mut self, args: Args) -> Self::Output;
}
```
```Rust
trait FnOnce<Args> {
    type Output;
    
    fn call_once(self, args: Args) -> Self::Output;
}
```
FnはFnMutを、FnMutはFnOnceを継承しています。

* Fnトレイトはクロージャの参照を引数にとり、何度でも呼び出し可能
* FnMutトレイトはクロージャの可変参照を引数にとり。何度でも呼び出し可能
* FnOnceトレイトはクロージャの移動を行い、**一度だけ**呼び出し可能

関数もクロージャも値で型をもち、引数にしたり、変数に格納出来たりします。

```Rust
fn f(a: i32) -> i32 {
    a 
}

fn fp1(a: i32, fp: fn(i32) -> i32) {
    println!("{}", fp(a));
}

fn main() {
    ...
    let c3 = |a: i32| -> i32 {a};
    fp1(5, f);  // 5
    fp1(5, c3); // 5
}
```
また、以下のようにトレイトオブジェクトや制約を用いて指定することもできます。

```Rust
fn fp2(a: i32, fp: Box<dyn Fn(i32) -> i32>) {
    println!("{}", fp(a));
}

または

fn fp2<T>(a: i32, fp: T) where T: Fn(i32) -> i32 {
    println!("{}", fp(a));
}

fn main() {
    ...
    fp2(5, Box::new(f));  
    fp2(5, Box::new(c3));
}
```

## FnOnce
もし、一度だけ呼び出されるようなクロージャを定義した場合、クロージャはFnOnceのみ実装します。以下の例を見てください。

```Rust
fn call_twice<T>(c: T) where T: Fn() {
    c();
    c();
}

fn main() {
    ...
    let s = String::from("drop me!");
    let c5 = || {
        drop(s);
    };
    c5();
    // c5(); // Error: double drop
    // call_twice(c5); // Error: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
}
```
クロージャc5は変数sをドロップします。c5を1度呼び出すと、2度目には同じ値をドロップしようとするのでコンパイル時にエラーを吐きます。この時クロージャはFnOnceを実装しています。call_twice関数はFnを制約としています。なのでcall_twiceの引数にc5を渡すとFnを実装していないと怒られます。
また意図せずに値を消費していることがあるので注意が必要です。

```Rust
fn main() {
    ...
    let v = vec![1];
    let c6 = move || v;
    c6();
    // c6(); // Error
}
```

## FnMut
FnMutはmutな値を保持したmutなクロージャを実装します。

```Rust
fn main() {
    ...
    let mut x = vec![5];
    let c7 = || {
        x.push(9);
    };
}
```
クロージャc7を例えば先ほどのcall_twiceに引数として入れると、FnMutを実装しており、Fnを実装していないためエラーを吐きます。
FnとFnMutのどちらも受け入れるようにするためには関数を以下のようにする必要があります。

```Rust
fn call_twice_mut<T>(mut c: T) where T: FnMut() {
    c();
    c();
}

fn main() {
    ...
    let mut v = vec![5];
    let mut c7 = || {
        v.push(9);
    };
    // call_twice(c7); // Error: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut` 
    call_twice_mut(c7);  // FnMut
    println!("{:?}", v); // [5, 9, 9]
    call_twice_mut(c4);  // Fn
}
```
これは、制約の指定を親トレイトとなるFnMutにしてあげることで、許容範囲が広がるため実行できます。

# ソース
```Rust
fn get_type<T>(_: T) -> &'static str {
    std::any::type_name::<T>()
}

fn f(a: i32) -> i32 {
    a 
}

fn fp1(a: i32, fp: fn(i32) -> i32) {
    println!("{}", fp(a));
}

// fn fp2(a: i32, fp: Box<dyn Fn(i32) -> i32>) {
//     println!("{}", fp(a));
// }

fn fp2<T>(a: i32, fp: T) where T: Fn(i32) -> i32 {
    println!("{}", fp(a));
}


fn call_twice<T>(c: T) where T: Fn() {
    c();
    c();
}

fn call_twice_mut<T>(mut c: T) where T: FnMut() {
    c();
    c();
}

fn return_closure(arg: i32) -> Box<dyn Fn() -> i32> {
    Box::new(move || {arg})
}

fn main() {
    let c0 = |x| x+1;
    println!("{}", c0(10));
    // move or not
    let x = 1;
    let c1 = || println!("{}", x);
    c1();
    let num = vec![5];
    let arg = vec![6];
    println!("num: {:p}", &num);
    println!("arg: {:p}", &arg);
    let c2 = |arg| {
        println!("num: {:p}", &num);
        println!("arg: {:p}", &arg);
    };
    c2(arg);
    // println!("num: {:p}", &num);
    // println!("arg: {:p}", &arg);
    // type of closure
    let c3 = |a: i32| -> i32 {a};
    fp1(5, f);
    fp1(5, c3);
    fp2(5, Box::new(f));
    fp2(5, Box::new(c3));
    // Fn
    let c4 = || println!("{}", 5);
    call_twice(c4);
    // FnOnce
    let s = String::from("drop me!");
    let c5 = || {
        drop(s);
    };
    c5();
    // c5(); // Error: double drop
    // call_twice(c5); // Error: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
    let v = vec![1];
    let c6 = move || v;
    c6();
    // c6(); // Error: double drop
    // FnMut
    let mut v = vec![5];
    let c7 = || {
        v.push(9);
    };
    // call_twice(c7); // Error: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut` 
    call_twice_mut(c7);  // FnMut
    println!("{:?}", v); // [5, 9, 9]
    call_twice_mut(c4);  // Fn
    // return closure
    let mut closures: Vec<Box<dyn Fn()->i32>> = Vec::new();
    closures.push(return_closure(999));
    closures.push(return_closure(9));
    println!("{}", closures[0]());
    println!("{}", closures[1]());
}
```
```
11
1
num: 0x770672f578
arg: 0x770672f590
num: 0x770672f578
arg: 0x770672f650
5
5
5
5
5
5
[5, 9, 9]
5
5
999
9
```

今回はここまでー。
クロージャはよく見る文法だったのでここで学べて良かったです。高速で安全とのことなので積極的に使っていきたいですね！