Fermetures Rust

Une fermeture en Rust est une fonction anonyme qui peut capturer et stocker des variables de son environnement.

Les fermetures permettent d'accéder à des variables en dehors de la portée dans laquelle elles sont définies, et peuvent les déplacer ou les emprunter dans la fermeture lorsque c'est nécessaire.

Les fermetures sont largement utilisées en Rust dans des domaines tels que la programmation fonctionnelle, la programmation concurrente et la programmation événementielle.


Différence entre les fermetures et les fonctions

Les fermetures et les fonctions ordinaires peuvent toutes deux encapsuler une partie de logique, mais les fermetures possèdent une capacité essentielle supplémentaire : capturer des variables de l'environnement externe. Le tableau suivant liste les principales différences entre les deux :

FonctionnalitéFermetureFonction
AnonymatPas de nom ; généralement assigné à une variableA un nom fixefnname
Capture de l'environnementPeut capturer des variables externesNe peut pas capturer des variables externes
Syntaxe de définition|paramètres| expressionfn nom(paramètres)
Inférence de typeLes types de paramètre et de retour peuvent généralement être omisDoit spécifier explicitement les types de paramètre et de retour
Stockage et passagePeut servir de variable, paramètre ou valeur de retourÉgalement pris en charge

Déclaration et appel de fermetures

La syntaxe de base d'une fermeture est la suivante :

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

Les paramètres peuvent avoir des annotations de type, ou elles peuvent être omises — le compilateur Rust les infère à partir du contexte.

Exemple

fn main() {
    // Fermeture : annotations de type omises, le compilateur les infère automatiquement
    let add_one = |x| x + 1;
    println!("add_one(4) = {}", add_one(4)); // Sortie : 5

    // Fermeture : annoter explicitement les types de paramètre et de retour
    let multiply = |a: i32, b: i32| -> i32 { a * b };
    println!("multiply(3, 7) = {}", multiply(3, 7)); // Sortie : 21

    // Une fermeture multiligne nécessite des accolades
    let greet = |name: &str| {
        let greeting = format!("Hello, {}!", name);
        greeting
    };
    println!("{}", greet("example")); // Sortie : Hello, example!
}

Les fermetures sont appelées exactement de la même manière que les fonctions ordinaires : ajoutez des parenthèses après le nom de la variable et passez les arguments.


Capture des variables externes

La caractéristique la plus essentielle d'une fermeture est sa capacité à capturer des variables depuis la portée dans laquelle elle est définie. C'est la différence fondamentale entre les fermetures et les fonctions ordinaires.

Les fermetures peuvent capturer des variables externes de trois manières :

Méthode de captureSémantique Rust correspondanteDescription
Capture par référenceSimilaire à&TComportement par défaut ; la closure emprunte la variable, et elle reste utilisable à l'extérieur
Capture par emprunt mutableSimilaire à&mut TLa closure doit modifier la variable ; la closure elle-même doit être déclarée commemut
Capture par valeurSimilaire àTUtilisermovemot-clé, en déplaçant la propriété de la variable dans la closure

Pour les types qui implémententCopyle trait (commei32、bool),moveseule une copie de la valeur est effectuée, et la variable externe reste utilisable. Par conséquent, pour démontrer le transfert de propriété, choisissezString、Vecet d'autres non-Copytypes.

Capture par référence

Par défaut, une fermeture emprunte les variables externes par référence immuable. Une fois l'emprunt terminé, la portée externe peut continuer à utiliser la variable.

Exemple

fn main() {
    let text = String::from("example");
    // La fermeture capture text par référence et ne prend pas possession de text
    let print_text = || println!("text = {}", text);
    print_text(); // Sortie : text = example
    // L'emprunt est terminé ; text peut encore être utilisé à l'extérieur
    println!("Still usable outside: {}", text);
}

Capture par emprunt mutable

Si une fermeture doit modifier une variable capturée, Rust la capture par référence mutable. Dans ce cas, la fermeture elle-même doit être déclarée commemut。

Exemple

fn main() {
    let mut counter = 0;
    // La fermeture capture counter par &mut ; la fermeture elle-même doit également être déclarée comme mut
    let mut inc = || {
        counter += 1;
    };
    inc();
    inc();
    println!("counter = {}", counter); // Sortie : counter = 2
}

Capture par valeur (move)

En ajoutant lemovemot-clé avant la fermeture, la fermeture prend possession des variables capturées. Une fois la propriété transférée, la portée externe ne peut plus utiliser la variable.

Exemple

fn main() {
    let owned = String::from("EXAMPLE");
    // move transfère la propriété de owned à la fermeture
    let take_owned = move || println!("owned = {}", owned);
    take_owned(); // Sortie : owned = EXAMPLE
    // Si vous décommentez la ligne ci-dessous, la compilation échouera : la propriété de owned a été déplacée dans la fermeture
    // println!("{}", owned);
}

Lorsqu'une fermeture doit être transmise à un autre thread ou renvoyée en dehors de sa portée,movec'est particulièrement courant — cela garantit que la fermeture possède les données requises et évite les références pendantes.


Traits de fermeture : Fn / FnMut / FnOnce

Le compilateur Rust implémente automatiquement le trait correspondant pour une closure en fonction de la façon dont elle capture les variables. Comprendre ces trois traits est la clé pour utiliser les closures comme paramètres de fonction ou valeurs de retour.

TraitMéthode de captureNombre d'appelsScénario typique
FnEmprunt immuable (&T)Plusieurs foisAccès en lecture seule aux variables capturées
FnMutEmprunt mutable (&mut T)Plusieurs foisDoit modifier les variables capturées
FnOncePrend possession (T)Une seule foisConsomme les variables capturées ; ne peut plus être appelée par la suite

La relation d'héritage entre les trois est :FnOuiFnMutest un sous-trait de,FnMutOuiFnOnceest un sous-trait de. Autrement dit, une fermeture qui implémenteFnimplémente également automatiquementFnMutetFnOnce。

Remarque :moveLe mot-clé force simplement la prise de propriété ; cela ne signifie pas que la fermeture doit êtreFnOnce. Si le corps de la fermeture ne consomme pas la valeur capturée, même simoveest ajouté, la fermeture peut encore implémenterFn(peut être appelée plusieurs fois).

Exemple

fn main() {
    let name = String::from("example");

    // Fermeture Fn : ne fait que lire, ne modifie pas et peut être appelée plusieurs fois
    let greet = || println!("Hello, {}!", name);
    greet(); // Premier appel
    greet(); // Deuxième appel, fonctionne toujours bien

    // Closure FnMut : doit modifier les variables capturées
    let mut count = 0;
    let mut increment = || {
        count += 1;
        count
    };
    println!("increment() = {}", increment()); // Sortie : 1
    println!("increment() = {}", increment()); // Sortie : 2

    // Closure FnOnce : consomme les variables capturées, ne peut être appelée qu'une seule fois
    let data = String::from("EXAMPLE");
    let consume = move || {
        let _ = data; // Déplace data hors de l'environnement de la closure, en le consommant
        println!("les données ont été consommées");
    };
    consume();
    // consume(); // Si on le décommente, la compilation échoue : les closures FnOnce ne peuvent être appelées qu'une seule fois
}

Les fermetures comme paramètres et valeurs de retour

Les fermetures peuvent être passées comme paramètres de fonction et renvoyées comme valeurs de retour de fonction. Ce sont les deux utilisations les plus courantes des fermetures dans le développement réel.

Les fermetures comme paramètres

Lorsque vous utilisez une fermeture comme paramètre, vous devez spécifier le type de trait de la fermeture avec une borne générique. Dans l'exemple suivant, le paramètreFest contraint àFn(i32) -> i32, ce qui signifie une fermeture qui prend uni32paramètre et renvoiei32une valeur.

Exemple

// Définir une fonction qui prend une fermeture comme paramètre
fn apply<F>(val: i32, f: F) -> i32
où
    F: Fn(i32) -> i32, // F doit implémenter Fn(i32) -> i32
{
    f(val)
}

fn main() {
    let double = |x| x * 2;
    let result = apply(5, double);
    println!("Résultat : {}", result); // Sortie : Résultat : 10

    // Vous pouvez aussi passer directement une fermeture anonyme
    let result2 = apply(3, |x| x + 100);
    println!("Résultat2 : {}", result2); // Sortie : Résultat2 : 103
}

Les fermetures comme valeurs de retour

Comme le type d'une fermeture est anonyme, retourner une fermeture nécessiteimpl TraitouBox<dyn Trait>de décrire le type de retour.

Retourner une fermeture avec impl Fn

Lorsque le type de la fermeture retournée peut être déterminé au moment de la compilation, utilisezimpl Fnet aucune allocation sur le tas n'est nécessaire.

Exemple

// Retourne une fermeture qui capture le paramètre x et l'ajoute à la valeur passée
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    // Doit utiliser move ; sinon x est une référence locale, et x devient invalide après le retour de la fermeture
    move |y| x + y
}

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

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

Utiliser Box<dyn Fn> pour retourner des fermetures

Lorsque vous devez sélectionner dynamiquement différentes fermetures à retourner à l'exécution, utilisezBox<dyn Fn>Allouer la fermeture sur le tas.

Exemple

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)); // Sortie : 10 + 2 = 12
}
MéthodeEmplacement d'allocationScénarios applicables
impl FnPileLe type de closure peut être déterminé au moment de la compilation, ce qui améliore les performances
Box<dyn Fn>TasSélectionner dynamiquement des closures au moment de l'exécution, ou avoir besoin de stocker des closures entre les fonctions

Cas d'utilisation courants

Les closures sont omniprésentes dans le développement quotidien en Rust. Voici plusieurs des scénarios d'application les plus typiques.

Closures dans les itérateurs

Les closures sont souvent utilisées avec les méthodes d'itérateur pour traiter par lots les éléments d'une collection.

Exemple

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

    // map : transformer chaque élément
    let squared: Vec<i32> = nums.iter().map(|x| x * x).collect();
    println!("squares: {:?}", squared); // Sortie : [1, 4, 9, 16, 25]

    // filter : filtrer les éléments qui satisfont la condition
    let even: Vec<&i32> = nums.iter().filter(|x| *x % 2 == 0).collect();
    println!("evens: {:?}", even); // Sortie : [2, 4]

    // fold : réduire une collection à une seule valeur
    let sum: i32 = nums.iter().fold(0, |acc, x| acc + x);
    println!("sum: {}", sum); // Sortie : 15
}

Fermetures et multithreading

En programmation multithread, les fermetures sont souvent utilisées pour définir le corps d'exécution d'un thread.moveLe mot-clé `move` est presque essentiel dans ce scénario, car il déplace la propriété des données dans le nouveau thread, empêchant les références entre threads de devenir invalides.

Exemple

use std::thread;

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

    // Créer un thread pour chaque nombre ; move transfère la propriété de num dans le thread
    let handles: Vec<_> = nums.into_iter().map(|num| {
        thread::spawn(move || {
            num * 2
        })
    }).collect();

    // Attendre que tous les threads se terminent et collecter les résultats
    for handle in handles {
        let result = handle.join().unwrap();
        println!("Résultat : {}", result);
    }
}

Fermetures et gestion des erreurs

Les fermetures peuvent retournerResultouOptiontypes qui, combinés aux méthodes d'itérateur, mettent en œuvre une logique concise de gestion des erreurs.

Exemple

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

    // Utiliser une fermeture pour trouver le premier nombre positif
    let first_positive = nums.iter().find(|&amp;&amp;x| x > 0);
    match first_positive {
        Some(&amp;n) => println!("Premier nombre positif : {}", n), // Sortie : Premier nombre positif : 3
        None => println!("Aucun nombre positif"),
    }

    // Utiliser une closure pour filtrer et transformer, en combinaison avec Result pour gérer les erreurs possibles
    let results: Vec<Result<i32, &amp;str>> = nums.iter().map(|&amp;n| {
        if n > 0 {
            OK(n * 10)
        } else {
            Err("Les nombres négatifs ne peuvent pas être traités")
        }
    }).collect();

    for r in results {
        correspondance r {
            Ok(v) => println!("Succès : {}", v),
            Err(e) => println!("Erreur : {}", e),
        }
    }
}

Performance et durées de vie

Performance des closures

Les closures de Rust sont légères. Le compilateur effectue des optimisations d'inlining sur les closures, ce qui rend le surcoût des appels de closure proche de celui d'un appel direct à des fonctions ordinaires. Les closures elles-mêmes n'introduisent pas d'appels de fonctions virtuelles supplémentaires ni d'allocations sur le tas (sauf si l'on utilise explicitementBox)。

Closures et durées de vie

La durée de vie d'une closure est étroitement liée aux variables qu'elle capture. Le système de durées de vie de Rust garantit qu'une closure ne survit à aucune des variables qu'elle capture — si une closure référence une variable locale, le compilateur vous empêchera de renvoyer la closure en dehors de la portée de cette variable au moment de la compilation.

Exemple

fn main() {
    let text = String::from("example");

    // Correct : utiliser la closure dans la portée de text
    let print_text = || println!("{}", text);
    print_text(); // Sortie : exemple

    // Si vous essayez de renvoyer cette fermeture, le compilateur signalera une erreur :
    // fn make_closure() -> impl Fn() {
    // let text = String::from("example");
    // || println!("{}", text) // Erreur : la durée de vie de text n'est pas assez longue
    // }
    // Solution : utilisez move pour transférer la propriété dans la fermeture
}

Exemple complet

L'exemple suivant démontre de manière complète les utilisations principales des fermetures telles que la déclaration, la capture de variables externes et le passage en tant qu'arguments.

Exemple

// Définir une fonction qui accepte une fermeture comme paramètre
fn apply_operation<F>(num: i32, operation: F) -> i32
où
    F: Fn(i32) -> i32,
{
    operation(num)
}

fn main() {
    let num = 5;

    // Définir une fermeture : élever un nombre au carré
    let square = |x| x * x;

    // Passer la fermeture à la fonction comme argument
    let result = apply_operation(num, square);
    println!("Le carré de {} est {}", num, result); // Sortie : Le carré de 5 est 25

    // Vous pouvez aussi passer directement une fermeture anonyme
    let result2 = apply_operation(num, |x| x * x * x);
    println!("Le cube de {} est {}", num, result2); // Sortie : Le cube de 5 est 125
}

Exécutez le programme ; la sortie est la suivante :

Square of 5 is 25
Cube of 5 is 125

Résumé

Les fermetures de Rust sont une abstraction puissante qui offre un moyen flexible et expressif d'encapsuler la logique.

Les fermetures peuvent capturer des variables d'environnement et peuvent être passées comme paramètres ou renvoyées comme valeurs de retour. Lorsqu'elles sont combinées avec des itérateurs, les fermetures peuvent facilement mettre en œuvre des tâches complexes de traitement de données.

La conception des fermetures de Rust prend en compte la sûreté, les performances et la durée de vie — le compilateur garantit au moment de la compilation que les fermetures ne référencent pas de variables invalidées, et garantit une abstraction à coût nul pour les appels de fermetures grâce à l'optimisation par inlining.

Autres extensions