Domain Specific Languages

RustRustBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, nous explorons le concept de Domain Specific Languages (DSLs) en Rust, qui sont de mini "langages" intégrés dans les macros Rust. Ces macros se développent en constructions Rust normales, mais offrent une syntaxe concise et intuitive pour une fonctionnalité spécifique. Un exemple pratique est démontré en utilisant une API de calculatrice, où une expression est fournie à la macro et la sortie est imprimée dans la console. Cela permet de créer des interfaces plus complexes comme celles trouvées dans des bibliothèques telles que lazy_static ou clap.

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") subgraph Lab Skills rust/variable_declarations -.-> lab-99229{{"Domain Specific Languages "}} rust/function_syntax -.-> lab-99229{{"Domain Specific Languages "}} rust/expressions_statements -.-> lab-99229{{"Domain Specific Languages "}} end

Domain Specific Languages (DSLs)

Un DSL est un mini "langage" intégré dans une macro Rust. C'est complètement du Rust valide car le système de macros se développe en constructions Rust normales, mais il ressemble à un petit langage. Cela vous permet de définir une syntaxe concise ou intuitive pour une certaine fonctionnalité spécifique (dans des limites).

Supposons que je veuille définir une petite API de calculatrice. Je voudrais fournir une expression et avoir la sortie imprimée dans la console.

macro_rules! calculate {
    (eval $e:expr) => {
        {
            let val: usize = $e; // Forcer les types à être des entiers
            println!("{} = {}", stringify!{$e}, val);
        }
    };
}

fn main() {
    calculate! {
        eval 1 + 2 // hehehe `eval` n'est _pas_ un mot clé Rust!
    }

    calculate! {
        eval (1 + 2) * (3 / 4)
    }
}

Sortie :

1 + 2 = 3
(1 + 2) * (3 / 4) = 0

C'était un exemple très simple.

Notez également les deux paires d'accolades dans la macro. Les accolades externes sont une partie de la syntaxe de macro_rules!, en plus de () ou [].

Summary

Félicitations! Vous avez terminé le laboratoire sur les Domain Specific Languages (DSLs). Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.