Julia Métaprogrammation

Julia représente son propre code sous forme de structures de données dans le langage, ce qui nous permet d'écrire des programmes qui manipulent des programmes.

La métaprogrammation peut aussi être simplement comprise comme l'écriture de code capable de générer du code.

La méta-programmation désigne l'écriture d'une certaine classe de programmes informatiques qui écrivent ou manipulent d'autres programmes (ou eux-mêmes) comme leurs données, ou qui accomplissent à la compilation une partie du travail qui aurait dû être fait à l'exécution. Dans la plupart des cas, par rapport à l'écriture de tout le code à la main, les programmeurs peuvent atteindre une efficacité de travail supérieure, ou donner au programme une plus grande flexibilité pour gérer de nouvelles situations sans recompiler.

Le langage utilisé pour écrire des métaprogrammes est appelé le métalangage. Le langage du programme manipulé est appelé le « langage cible ». La capacité d'un langage de programmation à être aussi son propre métalangage est appelée « réflexion » ou « réflexivité ».

-- Wikipédia

Étapes d'exécution du code source Julia

1. Analyser le code Julia d'origine: L'analyseur syntaxique de Julia analyse d'abord la chaîne pour obtenir un arbre syntaxique abstrait (AST), qui est une structure contenant tout le code dans un format facile à manipuler.

2. Exécuter le code Julia analysé :: À cette étape, le code Julia analysé est exécuté.

Lorsque nous saisissons du code dans l'environnement de programmation interactif (REPL) et appuyons sur Entrée, les deux étapes ci-dessus sont exécutées.

Avec les outils de méta-programmation, nous pouvons accéder au code Julia entre ces deux étapes, c'est-à-dire après que le code source a été analysé mais avant qu'il ne soit exécuté.

Représentation du programme

Julia fournit un module Meta, dans lequel Meta.parse(str) peut être utilisé pour analyser une chaîne, et typeof(e1) renvoie Expr :

Exemple

julia> prog = "1 + 1"
"1 + 1"
julia> ex1 = Meta.parse(prog)
:(1 + 1)

julia> typeof(ex1)
Expr

Renvoie:(1 + 1)La valeur renvoyée se compose d’un deux-points et de l’expression suivante ; typeof(ex1) renvoie Expr.

L’objet Expr contient deux parties (ex1 contient les attributs head et args) :

L’un est un objet symbole qui identifie le type de l’expression.

Exemple

julia> ex1.head
:call

L’autre regroupe les arguments de l’expression, qui peuvent être des symboles, d’autres expressions ou des littéraux :

Exemple

julia> ex1.args
3-element Vector{Any}:
  :+
 1
 1

Les expressions peuvent également être construites directement avec Expr :

Exemple

julia> ex2 = Expr(:call, :+, 1, 1)
:(1 + 1)

Les deux expressions construites ci-dessus, l’une par analyse syntaxique et l’autre par construction directe, sont équivalentes :

Exemple

julia> ex1 == ex2
vrai

Les objets Expr peuvent également être imbriqués :

Exemple

julia> ex3 = Meta.parse("(4 + 4) / 2")
:((4 + 4) / 2)

Nous pouvons également utiliser Meta.show_sexpr pour afficher les expressions. L'exemple suivant montre des Expr imbriqués :

Exemple

julia> Meta.show_sexpr(ex3)
(:call, :/, (:call, :+, 4, 4), 2)

Symboles

Nous pouvons utiliser l'opérateur préfixe deux-points:pour stocker une expression analysée mais non évaluée.

Exemple

julia> ABC = 100
100

julia> :ABC
:ABC

Mettez l'expression entière ci-dessous entre guillemets :

Exemple

julia> :(100-50)
:(100 - 50)

Citez une expression arithmétique :

Exemple

julia> ex = :(a+b*c+1)
:(a + b * c + 1)

julia> typeof(ex)
Expr

Notez que des expressions équivalentes peuvent également être construites en utilisant Meta.parse ou directement avec Expr :

Exemple

julia>      :(a + b*c + 1)       ==
       Meta.parse("a + b*c + 1") ==
       Expr(:call, :+, :a, Expr(:call, :*, :b, :c), 1)
vrai

Citer plusieurs expressions peut aussiquote ... endinclure un bloc de code dedans.

Exemple

julia> ex = quote
           x = 1
           y = 2
           x + y
       end
quote
    #= none:2 =#
    x = 1
    #= none:3 =#
    y = 2
    #= none:4 =#
    x + y
end

julia> typeof(ex)
Expr

Exécution d'expressions

Après qu'une expression a été analysée, nous pouvons utiliser la fonction eval() pour l'exécuter :

Exemple

julia> ex1 = :(1 + 2)
:(1 + 2)

julia> eval(ex1)
3

julia> ex = :(a + b)
:(a + b)

julia> eval(ex)
ERROR: UndefVarError: b not defined
[...]

julia> a = 1; b = 2;

julia> eval(ex)
3

Arbre syntaxique abstrait (AST)

Un arbre syntaxique abstrait (AST) est une structure qui est une représentation abstraite de la structure grammaticale du code source.

Il représente la structure syntaxique d'un langage de programmation sous forme d'arbre ; chaque nœud de l'arbre représente une structure dans le code source.

Nous pouvons visualiser la structure hiérarchique d'une expression avec la fonction dump() :

Exemple

julia> dump(:(1 * cos(pi/2)))
Expr
   head: Symbol call
   args: Array{Any}((3,))
      1: Symbole *
      2: Int64 1
      3: Expr
         head: Symbol call
         args: Array{Any}((2,))
            1: Symbol cos
            2: Expr
               head: Symbol call
               args: Array{Any}((3,))
                  1: Symbole /
                  2: Symbol pi
                  3: Int64 2

Interpolation

Bien que la construction directe d'objets Expr avec des paramètres de valeur soit puissante, comparée à la syntaxe Julia, le constructeur Expr peut sembler fastidieux. Comme alternative, Julia permet d'insérer des littéraux ou des expressions dans des expressions citées. L'interpolation d'expression est indiquée par le préfixe $.

Dans cet exemple, la valeur de la variable a est interpolée :

Exemple

julia> a = 1;

julia> ex = :($a + b)
:(1 + b)

L'interpolation dans une expression non citée n'est pas prise en charge, ce qui provoque une erreur de compilation :

julia> $a + b
ERROR: syntax: "$" expression outside quote

Dans cet exemple, le tuple (1,2,3) est inséré comme expression dans le test conditionnel :

julia> ex = :(a in $:((1,2,3)) )
:(a in (1, 2, 3))

L'utilisation de $ dans l'interpolation d'expression rappelle délibérément l'interpolation de chaînes et l'interpolation de commandes. L'interpolation d'expression rend la construction programmatique d'expressions Julia complexes pratique et lisible.

Macro

Les macros fournissent un mécanisme pour inclure du code généré dans le corps final d'un programme. Une macro associe un ensemble d'arguments à une expression renvoyée, et l'expression générée est compilée directement sans nécessiter d'appel à eval à l'exécution. Les arguments de macro peuvent inclure des expressions, des littéraux et des symboles.

Voici une macro très simple :

Exemple

julia> macro sayhello()
           return :( println("Hello, world!") )
       end
@sayhello (macro avec 1 méthode)

Dans la syntaxe de Julia, les macros ont un caractère spécial @ (arobase), immédiatement suivi d'un nom de macro unique déclaré sous la forme macro NAME ... end. Dans cet exemple, le compilateur remplacera tous les @sayhello par :

:( println("Hello, world!") )

Lorsque @sayhello est saisi dans le REPL, l'interpréteur l'exécute immédiatement, donc on ne voit que le résultat évalué :

julia> @sayhello()
Hello, world!

Maintenant, considérons une macro légèrement plus complexe :

Exemple

julia> macro sayhello(name)
 return :( println("Hello, ", $name) )
 end
@sayhello (macro avec 1 méthode)

Cette macro accepte un argument nommé name. Lorsque @sayhello est rencontré, l'expression citée est développée et la valeur de l'argument est insérée dans l'expression finale :

Exemple

julia> @sayhello("human")
Hello, human

Nous pouvons utiliser la fonction macroexpand pour voir l'expression citée renvoyée :

Exemple

julia> ex = macroexpand(Main, :(@sayhello("human")) )
:(Main.println("Hello, ", "human"))

julia> typeof(ex)
Expr

Nous pouvons voir que le littéral "human" a été inséré dans l'expression.

Il existe également une macro @macroexpand, qui peut être plus pratique que la fonction macroexpand :

Exemple

julia> @macroexpand @sayhello "human"
:(println("Hello, ", "human"))
Autres extensions