Rust クロージャ

Rust のクロージャは匿名関数であり、置かれている環境の変数をキャプチャして保存することができます。

クロージャは、定義されたスコープの外にある変数へのアクセスを可能にし、必要に応じてその変数をクロージャに移動または借用させて使用できます。

クロージャは Rust において、関数型プログラミング、並行プログラミング、イベント駆動プログラミングなどの分野で広く応用されています。


クロージャと関数の違い

クロージャと通常の関数はどちらもロジックをカプセル化できますが、クロージャにはもう1つの中核的な能力、すなわち外部環境の変数をキャプチャする能力があります。以下の表に両者の主な違いを示します。

特徴クロージャ関数
匿名性名前がなく、通常は変数に代入される固定されたfn名前
環境キャプチャ外部変数をキャプチャできる外部変数をキャプチャできない
定義方法|引数| 式fn 名前(引数)
型推論引数と戻り値の型は通常省略できる引数と戻り値の型を明示的に指定する必要がある
格納と受け渡し変数、引数、戻り値として使用できる同様にサポートされる

クロージャの宣言と呼び出し

クロージャの基本構文は次のとおりです。

let closure_name = |参数列表| 表达式或语句块;

引数には型注釈を付けることもできますが、省略することもできます。Rust コンパイラはコンテキストに基づいてそれらを推論します。

例

fn main() {
    // クロージャ: 型注釈を省略し、コンパイラが自動的に推論
    let add_one = |x| x + 1;
    println!("add_one(4) = {}", add_one(4)); // 出力: 5

    // クロージャ: 引数と戻り値の型を明示的に指定
    let multiply = |a: i32, b: i32| -> i32 { a * b };
    println!("multiply(3, 7) = {}", multiply(3, 7)); // 出力: 21

    // 複数行のクロージャは中括弧が必要
    let greet = |name: &str| {
        let greeting = format!("Hello, {}!", name);
        greeting
    };
    println!("{}", greet("サンプル")); // 出力: Hello, サンプル!
}

クロージャの呼び出し方は通常の関数とまったく同じで、変数名の後に括弧を付けて引数を渡すだけです。


外部変数のキャプチャ

クロージャの最も中核的な特性は、自分が置かれているスコープ内の変数をキャプチャできることです。これがクロージャと通常の関数の本質的な違いです。

クロージャは3つの方法で外部変数をキャプチャできます。

キャプチャ方法対応する Rust のセマンティクス説明
参照によるキャプチャ類似 `&`&Tデフォルトの動作。クロージャは変数を借用し、外部からは引き続き使用できます。
可変借用によるキャプチャ類似 `&mut`&mut Tクロージャが変数を変更する必要がある場合は、クロージャ自体を `mut` として宣言する必要があります。mut
値によるキャプチャ類似 `move`T`move` キーワードを使用しmove変数の所有権をクロージャに移します。

`Copy` trait を実装したCopy型(例えば `i32`)は、i32、bool),move単に値をコピーするだけで、外部の変数は引き続き使用できます。したがって、所有権の移動を示す場合は選んでください:String、Vec`String` などの非Copy`Copy` 型。

参照によるキャプチャ

デフォルトでは、クロージャは外部変数を不変参照として借用します。借用が終了すると、外部スコープはその変数を引き続き使用できます。

例

fn main() {
    let text = String::from("サンプル");
    // 闭包按引用捕获 text,不获取所有权
    let print_text = || println!("text = {}", text);
    print_text(); // 输出: text = サンプル
    // 借用已结束,外部仍然可以使用 text
    println!("外部仍可使用: {}", text);
}

可変借用によるキャプチャ

クロージャがキャプチャした変数を変更する必要がある場合、Rust は可変参照としてキャプチャします。この場合、クロージャ自体は `mut` として宣言する必要があります。mut。

例

fn main() {
    let mut counter = 0;
    // クロージャは &mut で counter をキャプチャし、クロージャ自体も mut として宣言する必要があります
    let mut inc = || {
        counter += 1;
    };
    inc();
    inc();
    println!("counter = {}", counter); // 输出: counter = 2
}

値によるキャプチャ(move)

クロージャの前に追加することでmove`move` キーワードを付けると、クロージャはキャプチャした変数の所有権を取得します。所有権が移動した後は、外部スコープはその変数をそれ以上使用できなくなります。

例

fn main() {
    let owned = String::from("サンプル");
    // move は owned の所有権をクロージャに移す
    let take_owned = move || println!("owned = {}", owned);
    take_owned(); // 输出: owned = サンプル
    // 下の行のコメントを解除すると、コンパイルエラーになります:owned の所有権はクロージャに移されています。
    // println!("{}", owned);
}

クロージャを別のスレッドに渡す必要がある場合や、スコープの外に返す必要がある場合、move`move` が特に頻繁に使用されます。これにより、クロージャが必要なデータの所有権を保持し、ダングリング参照が発生しないことが保証されます。


クロージャのTrait: Fn / FnMut / FnOnce

Rust コンパイラは、クロージャが変数をキャプチャする方法に応じて、対応するトレイトを自動的に実装します。この3つのトレイトを理解することが、クロージャを関数の引数や戻り値として使用するための鍵となります。

Trait捕获方式可调用次数典型场景
Fn不変借用(&T)多次キャプチャした変数への読み取り専用アクセス
FnMut可变借用(&mut T)多次キャプチャした変数を変更する必要がある
FnOnce所有権を取得する(T)仅一次捕获変数を消費するため、以降は呼び出せなくなる

3つの関係は次のとおりです:FnであるFnMutのサブトレイト、FnMutであるFnOnce`FnMut` と `Fn` は `FnOnce` のサブトレイトです。つまり、`Fn` を実装したクロージャは、`FnMut` と `FnOnce` も同時に実装します。Fnのクロージャは、自動的に実装もされるFnMutとFnOnce。

注意:move`move` キーワードは所有権の取得を強制するだけで、クロージャが必ず `FnOnce` であることを意味するわけではありません。FnOnceクロージャ本体がキャプチャした値を消費しない場合、たとえ `move` を付けても、そのクロージャは `Fn` と `FnMut` を実装できます。move、クロージャは依然として実装可能であるFn(複数回呼び出し可能)。

例

fn main() {
    let name = String::from("サンプル");

    // Fn 闭包:只读取,不修改,可多次调用
    let greet = || println!("Hello, {}!", name);
    greet(); // 第一次调用
    greet(); // 第二调用,依然正常

    // FnMut 闭包:需要修改捕获变量
    let mut count = 0;
    let mut increment = || {
        count += 1;
        count
    };
    println!("increment() = {}", increment()); // 输出: 1
    println!("increment() = {}", increment()); // 输出: 2

    // FnOnce クロージャ:捕捉した変数を消費し、一度しか呼び出せない
    let data = String::from("サンプル");
    let consume = move || {
        let _ = data; // dataをクロージャ環境から取り出して消費する
        println!("data has been consumed");
    };
    consume();
    // consume(); // 若取消注释,编译报错:FnOnce 闭包只能调用一次
}

クロージャを引数と戻り値として使う

クロージャは関数の引数として渡すことも、関数の戻り値として返すこともできます。これは、クロージャが実際の開発で最も一般的に使われる2つの方法です。

引数としてのクロージャ

クロージャを引数として受け取る場合、トレイト境界でクロージャのトレイト型を指定する必要があります。次の例では、パラメータF制約されるFn(i32) -> i32、1つを受け取ることを示しますi32参数并返回i32のクロージャ。

例

// クロージャを引数として受け取る関数を定義する
fn apply<F>(val: i32, f: F) -> i32
where
    F: Fn(i32) -> i32, // F 必须实现 Fn(i32) -> i32
{
    f(val)
}

fn main() {
    let double = |x| x * 2;
    let result = apply(5, double);
    println!("Result: {}", result); // 输出: Result: 10

    // 也可以直接传入匿名闭包
    let result2 = apply(3, |x| x + 100);
    println!("Result2: {}", result2); // 输出: Result2: 103
}

戻り値としてのクロージャ

クロージャの型は匿名であるため、クロージャを返す場合は `impl Trait` 構文を使用する必要があります。impl Trait 或 Box<dyn Trait>戻り値の型を説明するために使用します。

impl Fn を使用してクロージャを返す

返すクロージャの型がコンパイル時に確定できる場合は、`impl Trait` を使用します。impl Fnでよく、ヒープ割り当ては不要である

例

// 引数 x をキャプチャし、渡された値と加算するクロージャを返す
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    // move は必須。そうでなければ x はローカル参照であり、クロージャが返った後、x は無効になる。
    move |y| x + y
}

fn main() {
    let add_five = make_adder(5);
    println!("5 + 3 = {}", add_five(3)); // 出力: 5 + 3 = 8

    let add_ten = make_adder(10);
    println!("10 + 2 = {}", add_ten(2)); // 出力: 10 + 2 = 12
}

Box<dyn Fn> を使用してクロージャを返す

実行時に異なるクロージャを動的に選択して返す必要がある場合に使用しますBox<dyn Fn>クロージャをヒープに割り当てます。

例

fn make_adder(x: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |y| x + y)
}

fn main() {
    let add_ten = make_adder(10);
    println!("10 + 2 = {}", add_ten(2)); // 出力: 10 + 2 = 12
}
方式割り当て位置適用シーン
impl Fn栈コンパイル時にクロージャの型を決定でき、パフォーマンスが向上します
Box<dyn Fn>堆実行時にクロージャを動的に選択する場合、または関数をまたいでクロージャを保存する必要がある場合

よくある応用シーン

クロージャは Rust の日常的な開発のいたるところで見られます。以下は、最も典型的ないくつかの適用シーンです。

イテレータでのクロージャ

クロージャはイテレータのメソッドと組み合わせて使用されることが多く、コレクションの要素を一括処理するために使用されます。

例

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

    // map: 各要素を変換する
    let squared: Vec<i32> = nums.iter().map(|x| x * x).collect();
    println!("二乗: {:?}", squared); // 出力: [1, 4, 9, 16, 25]

    // filter: 条件を満たす要素を絞り込む
    let even: Vec<&i32> = nums.iter().filter(|x| *x % 2 == 0).collect();
    println!("偶数: {:?}", even); // 出力: [2, 4]

    // fold: コレクションを単一の値に畳み込む
    let sum: i32 = nums.iter().fold(0, |acc, x| acc + x);
    println!("合計: {}", sum); // 出力: 15
}

クロージャとマルチスレッド

マルチスレッドプログラミングでは、クロージャはスレッドの実行本体を定義するためによく使用されます。movemove キーワードはこのシナリオではほぼ必須です。データの所有権を新しいスレッドに移すことで、スレッド間の参照の無効化を防ぐためです。

例

use std::thread;

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

    // 各数値に対してスレッドを作成し、move が num の所有権をスレッドに移す
    let handles: Vec<_> = nums.into_iter().map(|num| {
        thread::spawn(move || {
            num * 2
        })
    }).collect();

    // すべてのスレッドの完了を待って結果を収集する
    for handle in handles {
        let result = handle.join().unwrap();
        println!("Result: {}", result);
    }
}

クロージャとエラーハンドリング

クロージャはResult 或 Option型を返すことができ、イテレータのメソッドと組み合わせることで簡潔なエラーハンドリングロジックを実現できます。

例

fn main() {
    let nums = vec![3, -1, 4, -5, 9];

    // クロージャを使用して最初の正の数を検索する
    let first_positive = nums.iter().find(|&amp;&amp;x| x > 0);
    match first_positive {
        Some(&amp;n) => println!("最初の正の数: {}", n), // 出力: 最初の正の数: 3
        None => println!("正の数がありません"),
    }

    // クロージャでフィルタリングと変換を行い、Result と組み合わせて起こり得るエラーを処理する
    let results: Vec<Result<i32, &amp;str>> = nums.iter().map(|&amp;n| {
        if n > 0 {
            Ok(n * 10)
        } else {
            Err("負の数は処理できません")
        }
    }).collect();

    for r in results {
        match r {
            Ok(v) => println!("成功: {}", v),
            Err(e) => println!("エラー: {}", e),
        }
    }
}

パフォーマンスとライフタイム

クロージャのパフォーマンス

Rust のクロージャは軽量です。コンパイラはクロージャをインライン最適化し、クロージャ呼び出しのオーバーヘッドが通常の関数を直接呼び出すのに近くなります。クロージャ自体は追加の仮想関数呼び出しやヒープ割り当てを導入しません(明示的に使用しない限りBox)。

クロージャとライフタイム

クロージャのライフタイムは、キャプチャする変数と密接に関係しています。Rust のライフタイムシステムにより、クロージャはキャプチャしたどの変数よりも長く生存することはありません。クロージャがローカル変数を参照している場合、コンパイラはコンパイル時に、その変数のスコープ外へクロージャを返すことを防ぎます。

例

fn main() {
    let text = String::from("サンプル");

    // 正しい: クロージャを text のスコープ内で使用する
    let print_text = || println!("{}", text);
    print_text(); // 出力: サンプル

    // このクロージャを返そうとすると、コンパイラはエラーを報告します:
    // fn make_closure() -> impl Fn() {
    //     let text = String::from("サンプル");
    // || println!("{}", text) // エラー: text のライフタイムが十分ではありません
    // }
    // 解決策: move を使用して所有権をクロージャに移す
}

完全な例

以下の例は、クロージャの宣言、外部変数のキャプチャ、引数としての受け渡しなどの主要な使い方を総合的に示しています。

例

// クロージャを引数として受け取る関数を定義する
fn apply_operation<F>(num: i32, operation: F) -> i32
where
    F: Fn(i32) -> i32,
{
    operation(num)
}

fn main() {
    let num = 5;

    // クロージャを定義: 数値を二乗する
    let square = |x| x * x;

    // クロージャを関数に引数として渡す
    let result = apply_operation(num, square);
    println!("Square of {} is {}", num, result); // 出力: Square of 5 is 25

    // 匿名クロージャを直接渡すこともできます
    let result2 = apply_operation(num, |x| x * x * x);
    println!("Cube of {} is {}", num, result2); // 出力: Cube of 5 is 125
}

このプログラムを実行すると、出力は次のようになります:

Square of 5 is 25
Cube of 5 is 125

まとめ

Rust のクロージャは強力な抽象化であり、ロジックをカプセル化するための柔軟で表現力豊かな方法を提供します。

クロージャは環境変数をキャプチャでき、引数として渡したり戻り値として返したりできます。クロージャをイテレータと組み合わせて使用すると、複雑なデータ処理タスクを簡単に実装できます。

Rust のクロージャ設計は、安全性、パフォーマンス、ライフタイムを両立しています。コンパイラはコンパイル時にクロージャが無効化された変数を参照しないことを保証し、インライン最適化によりクロージャ呼び出しのゼロコスト抽象を保証します。

その他の拡張