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
"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
:call
L’autre regroupe les arguments de l’expression, qui peuvent être des symboles, d’autres expressions ou des littéraux :
Exemple
3-element Vector{Any}:
:+
1
1
Les expressions peuvent également être construites directement avec Expr :
Exemple
:(1 + 1)
Les deux expressions construites ci-dessus, l’une par analyse syntaxique et l’autre par construction directe, sont équivalentes :
Exemple
vrai
Les objets Expr peuvent également être imbriqués :
Exemple
:((4 + 4) / 2)
Nous pouvons également utiliser Meta.show_sexpr pour afficher les expressions. L'exemple suivant montre des Expr imbriqués :
Exemple
(: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
100
julia> :ABC
:ABC
Mettez l'expression entière ci-dessous entre guillemets :
Exemple
:(100 - 50)
Citez une expression arithmétique :
Exemple
:(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
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
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
:(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
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> 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
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
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
Hello, human
Nous pouvons utiliser la fonction macroexpand pour voir l'expression citée renvoyée :
Exemple
:(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
:(println("Hello, ", "human"))