Comment stocker un motif dans une variable en Rust ?

Question

Je suis en train d'implémenter un analyseur syntaxique en Rust et l'espace blanc est un motif commun que je veux réutiliser dans match modèles.

Ce code fonctionne :

let ch = ' ';

match ch {
    ' ' | '\n' | '\t' | '\r' => println!("whitespace"),
     _ => println!("token"),
}

Cela deviendrait vraiment répétitif si je devais continuer à spécifier le modèle d'espacement à chaque fois. J'aimerais pouvoir le définir une fois et le réutiliser. Je veux faire quelque chose comme :

let whitespace = ' ' | '\n' | '\t' | '\r';

let ch = ' ';

match ch {
    whitespace => println!("whitespace"),
    _          => println!("token"),
}

Le compilateur n'aime pas le ws affectation. Il interprète le | comme une opération binaire au lieu de l'alternance.

Les modèles peuvent-ils être stockés dans des variables d'une manière ou d'une autre ? Existe-t-il un moyen plus efficace ou plus idiomatique de le faire ?

Answer 1

Les modèles peuvent-ils être stockés dans des variables d'une manière ou d'une autre ?

Non. Les modèles sont une construction de compilation, et les variables contiennent des concepts d'exécution.

Existe-t-il une meilleure façon de procéder ou une façon plus idiomatique de le faire ?

La création d'une fonction ou d'une méthode est toujours une bonne solution pour éviter la répétition du code. Vous pouvez ensuite l'utiliser comme une clause de sauvegarde :

fn is_whitespace(c: char) -> bool {
    match c {
        ' ' | '\n' | '\t' | '\r' => true,
        _ => false,
    }
}

fn main() {
    let ch = ' ';

    match ch {
        x if is_whitespace(x) => println!("whitespace"),
        _ => println!("token"),
    }
}

---

Je recommande également vivement d'utiliser un analyseur syntaxique existant, dont il existe une multitude mais tout le monde veut que son "hello world" Rust soit analysé, pour une raison ou une autre.

Une bibliothèque d'analyse syntaxique que j'utilise permet d'écrire un code semblable à celui-ci, où whitespace est une fonction qui sait comment analyser les types d'espaces valides :

sequence!(pm, pt, {
    _          = literal("if");
    ws         = whitespace;
    _          = literal("let");
    ws         = append_whitespace(ws);
    pattern    = pattern;
    ws         = optional_whitespace(ws);
    _          = literal("=");
    ws         = optional_whitespace(ws);
    expression = expression;
}, |_, _| /* do something with pieces */);

Chacune des choses sur le côté droit sont toujours des fonctions individuelles qui savent comment analyser quelque chose de spécifique.