From 025511ff5f282c50fef28a1d8ee313462a5f17e9 Mon Sep 17 00:00:00 2001 From: Dimitri LESNOFF Date: Thu, 2 Nov 2023 17:04:01 +0100 Subject: [PATCH] Remove sketch of code blocks with numbers + warning fr trad --- blogPosts/macroTutorial_fr.html | 61 +++++++++++++++++++++------------ blogPosts/macroTutorial_fr.nim | 33 +++++++++++------- 2 files changed, 61 insertions(+), 33 deletions(-) diff --git a/blogPosts/macroTutorial_fr.html b/blogPosts/macroTutorial_fr.html index 638aae0..f48dbe9 100644 --- a/blogPosts/macroTutorial_fr.html +++ b/blogPosts/macroTutorial_fr.html @@ -68,20 +68,26 @@

Plan:

Introduction

+

Qu'est-ce que la métaprogrammation ?

+

La métaprogrammation consiste à programmer du code informatique. Autrement dit, l'entrée et la sortie de programmes réalisant de la métaprogrammation seront eux-mêmes des bouts de code.

-

Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)? -Le principal objectif est d'écrire facilement des longues portions de code qui sont répétitives ou pour s'adapter par exemple à de nombreuses architectures. +

+

Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)?

+
+

Le principal objectif est d'écrire facilement des longues portions de code qui sont répétitives ou pour s'adapter par exemple à de nombreuses architectures. Il est également possible d'écrire de mini-langages de programmation nommés DSL ("domain-specific languages") pour une utilisation précise, comme la description de contenu d'une fenêtre graphique avec Owlkettle ou pour spécifier les paramètres d'un réseau de neurones Arraymancer. Les macros sont écrites une fois par le développeur d'une bibliothèque, et les utilisateurs de cette bibliothèque vont voir leur code modifié par les macros sans même utiliser de macros par eux-mêmes.

+

Quel rapport avec les macros ?

+

Les macros sont ces fonctions qui vont travailler sur des bouts de code et générer du code en sortie. Nous verrons par la suite que ce code est représenté sous la forme d'arbre syntaxique nommé AST.

Quatre niveaux d'abstraction

Il existe quatre niveaux d'abstraction en métaprogrammation qui sont chacun associés à un type de procédure ou itérateur:

    -
  1. Procédures/fonctions/itérateurs ordinaires (Pas de métaprogrammation - niveau zéro)
    2. +
  2. Procédures/fonctions/itérateurs ordinaires (Pas de métaprogrammation)
  3. Les procédures génériques et les classes de type (Métaprogrammation au niveau du type)
  4. Les « modèles » template en anglais (Un méchanisme de copier-coller avancé)
  5. Les Macros (Substitution d'arbre syntaxique AST)
    6. @@ -147,10 +153,14 @@

    Templates

    ⚠️ Afin d'exécuter chaque code dans la suite de ce tutoriel, vous devrez importer le paquet std/macros.

    import std/macros
    -

    We can see templates as procedures that modify code through a copy-paste mechanism. Pieces of code are given to (and outputted by) the template with a special type : untyped. -For those familiar with preprocessing in the C family of languages (C, C++, C#), it does the same than the #define or #if, #endif macros and much more.

    -

    Nim's language defines boolean operator like != with templates. You can even look at Nim's source code, that's almost the same code. See the documentation.

    -
    echo "hello World"
    hello World
    +

    Nous pouvons voir les templates comme des procédures qui font de la substitution de code, comme un couper-coller qui serait réalisé à la compilation.

    +

    Les procédures templates reçoivent généralement en dernier paramètre un bout de code. +Le type qui correspond à un bout de code est untyped. +Comme nous souhaitons que le template retourne un bout de code, le type de retour est untyped pour presque tous les cas d'usage.

    +
    template `!=` (a, b: untyped): untyped =
+  not (a == b)
    +

    :warning: Le reste du tutoriel n'a pas encore été traduit de l'anglais vers le français.

    +

    The Nim language defines boolean operators like != with templates. You can even look at Nim's source code, that's almost the same code. See the documentation.

    ## Example from std/manual
 template `!=` (a, b: untyped): untyped =
   not (a == b)
@@ -223,7 +233,7 @@ 
    Benchmark example
    
     echo "CPU Time [", benchmarkName, "] ", elapsed
 
 benchmark "test1":
-  sleep(100)
    CPU Time [test1] 100 milliseconds, 126 microseconds, and 124 nanoseconds
    + sleep(100)
    CPU Time [test1] 100 milliseconds, 208 microseconds, and 351 nanoseconds

    The code inside the benchmark code block will be enclosed by our template code.

    Since the code replacement is done at compile time, this transformation does not add additional runtime to our benchmarked code. On the contrary, a function or procedure for benchmarking would have add runtime due to the nested function calls.

    @@ -659,7 +669,7 @@

    References and Bibliography

    # add a ToC var nbToc: NbBlock -enableLineNumbersDoc() + template addToc = newNbBlock("nbText", false, nb, nbToc, ""): nbToc.output = "### Plan:\n\n" @@ -682,17 +692,18 @@

    References and Bibliography

    nbSection "Introduction" nbText: hlMd""" -Qu'est-ce que la métaprogrammation ? +> Qu'est-ce que la métaprogrammation ? La métaprogrammation consiste à programmer du code informatique. Autrement dit, l'entrée et la sortie de programmes réalisant de la métaprogrammation seront eux-mêmes des bouts de code. -Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)? +> Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)? + Le principal objectif est d'écrire facilement des longues portions de code qui sont répétitives ou pour s'adapter par exemple à de nombreuses architectures. Il est également possible d'écrire de mini-langages de programmation nommés DSL ("domain-specific languages") pour une utilisation précise, comme la description de contenu d'une fenêtre graphique avec `Owlkettle` ou pour spécifier les paramètres d'un réseau de neurones `Arraymancer`. Les macros sont écrites une fois par le développeur d'une bibliothèque, et les utilisateurs de cette bibliothèque vont voir leur code modifié par les macros sans même utiliser de macros par eux-mêmes. -Quel rapport avec les macros ? +> Quel rapport avec les macros ? Les macros sont ces fonctions qui vont travailler sur des bouts de code et générer du code en sortie. Nous verrons par la suite que ce code est représenté sous la forme d'arbre syntaxique nommé AST. @@ -702,7 +713,7 @@

    References and Bibliography

    ### Quatre niveaux d'abstraction Il existe quatre niveaux d'abstraction en métaprogrammation qui sont chacun associés à un type de procédure ou itérateur: - 0. Procédures/fonctions/itérateurs ordinaires (Pas de métaprogrammation - niveau zéro) + 0. Procédures/fonctions/itérateurs ordinaires (Pas de métaprogrammation) 1. Les procédures génériques et les classes de type (Métaprogrammation au niveau du type) 2. Les « modèles » `template` en anglais (Un méchanisme de copier-coller avancé) 3. Les `Macro`s (Substitution d'arbre syntaxique `AST`) @@ -759,7 +770,7 @@

    References and Bibliography

    nbCodeSkip: proc add(x,y: (int or float)): (int or float) = return x + y - + add 2, 3 # Selects int add 3.7, 4.5 # Selects float @@ -779,7 +790,7 @@

    References and Bibliography

    return $c else: return c - + add 2, 3 # Selects int add 3.7, 4.5 # Selects float add "3.7", "4.5" @@ -793,16 +804,24 @@

    References and Bibliography

    import std/macros nbText: """ -We can see *templates* as procedures that modify code through a copy-paste mechanism. Pieces of code are given to (and outputted by) the template with a special type : `untyped`. -For those familiar with [preprocessing](https://gcc.gnu.org/onlinedocs/cpp/) in the C family of languages (C, C++, C#), it does the same than the `#define` or `#if`, `#endif` macros and much more. +Nous pouvons voir les *templates* comme des procédures qui font de la substitution de code, comme un couper-coller qui serait réalisé à la compilation. + +Les procédures `templates` reçoivent généralement en dernier paramètre un bout de code. +Le type qui correspond à un bout de code est `untyped`. +Comme nous souhaitons que le template retourne un bout de code, le type de retour est `untyped` pour presque tous les cas d'usage. """ -nbText: """ -Nim's language defines boolean operator like `!=` with templates. You can even look at Nim's source code, that's almost the same code. See the [documentation](https://nim-lang.org/docs/system.html#%21%3D.t%2Cuntyped%2Cuntyped). +nbCodeSkip: + template `!=` (a, b: untyped): untyped = + not (a == b) + +nbText:""" +:warning: Le reste du tutoriel n'a pas encore été traduit de l'anglais vers le français. """ -nbCodeWithNumbers: - echo "hello World" +nbText: """ +The Nim language defines boolean operators like `!=` with templates. You can even look at Nim's source code, that's almost the same code. See the [documentation](https://nim-lang.org/docs/system.html#%21%3D.t%2Cuntyped%2Cuntyped). +""" nbCode: ## Example from std/manual diff --git a/blogPosts/macroTutorial_fr.nim b/blogPosts/macroTutorial_fr.nim index 40a63c7..9b66c9f 100644 --- a/blogPosts/macroTutorial_fr.nim +++ b/blogPosts/macroTutorial_fr.nim @@ -6,7 +6,7 @@ nbInit # add a ToC var nbToc: NbBlock -enableLineNumbersDoc() + template addToc = newNbBlock("nbText", false, nb, nbToc, ""): nbToc.output = "### Plan:\n\n" @@ -29,17 +29,18 @@ addToc() nbSection "Introduction" nbText: hlMd""" -Qu'est-ce que la métaprogrammation ? +> Qu'est-ce que la métaprogrammation ? La métaprogrammation consiste à programmer du code informatique. Autrement dit, l'entrée et la sortie de programmes réalisant de la métaprogrammation seront eux-mêmes des bouts de code. -Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)? +> Mon language préféré ne me permet pas d'écrire des macros. Pourquoi écrire des macros (avec Nim)? + Le principal objectif est d'écrire facilement des longues portions de code qui sont répétitives ou pour s'adapter par exemple à de nombreuses architectures. Il est également possible d'écrire de mini-langages de programmation nommés DSL ("domain-specific languages") pour une utilisation précise, comme la description de contenu d'une fenêtre graphique avec `Owlkettle` ou pour spécifier les paramètres d'un réseau de neurones `Arraymancer`. Les macros sont écrites une fois par le développeur d'une bibliothèque, et les utilisateurs de cette bibliothèque vont voir leur code modifié par les macros sans même utiliser de macros par eux-mêmes. -Quel rapport avec les macros ? +> Quel rapport avec les macros ? Les macros sont ces fonctions qui vont travailler sur des bouts de code et générer du code en sortie. Nous verrons par la suite que ce code est représenté sous la forme d'arbre syntaxique nommé AST. @@ -106,7 +107,7 @@ Durant la phase de compilation, le compilateur Nim choisit quel type convient à nbCodeSkip: proc add(x,y: (int or float)): (int or float) = return x + y - + add 2, 3 # Selects int add 3.7, 4.5 # Selects float @@ -126,7 +127,7 @@ nbCodeSkip: return $c else: return c - + add 2, 3 # Selects int add 3.7, 4.5 # Selects float add "3.7", "4.5" @@ -140,16 +141,24 @@ nbCodeSkip: import std/macros nbText: """ -We can see *templates* as procedures that modify code through a copy-paste mechanism. Pieces of code are given to (and outputted by) the template with a special type : `untyped`. -For those familiar with [preprocessing](https://gcc.gnu.org/onlinedocs/cpp/) in the C family of languages (C, C++, C#), it does the same than the `#define` or `#if`, `#endif` macros and much more. +Nous pouvons voir les *templates* comme des procédures qui font de la substitution de code, comme un couper-coller qui serait réalisé à la compilation. + +Les procédures `templates` reçoivent généralement en dernier paramètre un bout de code. +Le type qui correspond à un bout de code est `untyped`. +Comme nous souhaitons que le template retourne un bout de code, le type de retour est `untyped` pour presque tous les cas d'usage. """ -nbText: """ -Nim's language defines boolean operator like `!=` with templates. You can even look at Nim's source code, that's almost the same code. See the [documentation](https://nim-lang.org/docs/system.html#%21%3D.t%2Cuntyped%2Cuntyped). +nbCodeSkip: + template `!=` (a, b: untyped): untyped = + not (a == b) + +nbText:""" +:warning: Le reste du tutoriel n'a pas encore été traduit de l'anglais vers le français. """ -nbCodeWithNumbers: - echo "hello World" +nbText: """ +The Nim language defines boolean operators like `!=` with templates. You can even look at Nim's source code, that's almost the same code. See the [documentation](https://nim-lang.org/docs/system.html#%21%3D.t%2Cuntyped%2Cuntyped). +""" nbCode: ## Example from std/manual