Metaprogrammierung in Julia
Julia stellt seinen eigenen Code als Datenstrukturen in der Sprache dar, sodass wir Programme schreiben können, die Programme manipulieren.
Metaprogrammierung kann auch einfach als das Schreiben von Code verstanden werden, der Code generieren kann.
Metaprogrammierung bezeichnet das Schreiben einer bestimmten Klasse von Computerprogrammen, die andere Programme (oder sich selbst) als ihre Daten schreiben oder manipulieren oder die zur Kompilierzeit einen Teil der Arbeit erledigen, die zur Laufzeit hätte erledigt werden sollen. In den meisten Fällen können Programmierer im Vergleich zum Schreiben des gesamten Codes von Hand eine höhere Arbeitseffizienz erreichen oder dem Programm eine größere Flexibilität verleihen, um neue Situationen ohne Neukompilierung zu bewältigen.
Die Sprache, die zum Schreiben von Metaprogrammen verwendet wird, heißt Metasprache. Die Sprache des manipulierten Programms wird als "Zielsprache" bezeichnet. Die Fähigkeit einer Programmiersprache, auch ihre eigene Metasprache zu sein, wird als "Reflexion" oder "Reflexivität" bezeichnet.
-- Wikipedia
Ausführungsstufen des Julia-Quellcodes
1. Den ursprünglichen Julia-Code parsen: Der Julia-Parser parst zunächst die Zeichenkette, um einen abstrakten Syntaxbaum (AST) zu erhalten, eine Struktur, die den gesamten Code in einem leicht manipulierbaren Format enthält.
2. Den geparsten Julia-Code ausführen:: In dieser Phase wird der geparste Julia-Code ausgeführt.
Wenn wir Code in der interaktiven Programmierumgebung (REPL) eingeben und die Eingabetaste drücken, werden die oben genannten beiden Phasen ausgeführt.
Mit Metaprogrammierungs-Werkzeugen können wir auf den Julia-Code zwischen diesen beiden Phasen zugreifen, das heißt, nachdem der Quellcode geparst wurde, aber bevor er ausgeführt wird.
Programmdarstellung
Julia bietet ein Meta-Modul, in dem Meta.parse(str) verwendet werden kann, um eine Zeichenkette zu parsen, und typeof(e1) gibt Expr zurück:
Beispiel
"1 + 1"
julia> ex1 = Meta.parse(prog)
:(1 + 1)
julia> typeof(ex1)
Expr
Gibt zurück:(1 + 1)Der zurückgegebene Wert besteht aus einem Doppelpunkt und dem folgenden Ausdruck; typeof(ex1) gibt Expr zurück.
Das Expr-Objekt enthält zwei Teile (ex1 enthält die Attribute head und args):
Eines ist ein Symbolobjekt, das den Typ des Ausdrucks identifiziert.
Beispiel
:call
Das andere sind die Argumente des Ausdrucks, die Symbole, andere Ausdrücke oder Literale sein können:
Beispiel
3-elementiger Vector{Any}:
:+
1
1
Ausdrücke können auch direkt mit Expr konstruiert werden:
Beispiel
:(1 + 1)
Die beiden oben konstruierten Ausdrücke, einer durch Parsen und einer durch direkte Konstruktion, sind äquivalent:
Beispiel
wahr
Expr-Objekte können auch verschachtelt sein:
Beispiel
:((4 + 4) / 2)
Wir können auch Meta.show_sexpr verwenden, um Ausdrücke anzuzeigen. Das folgende Beispiel demonstriert verschachtelte Expr:
Beispiel
(:call, :/, (:call, :+, 4, 4), 2)
Symbole
Wir können den Doppelpunkt-:Präfixoperator verwenden, um einen nicht ausgewerteten, aber geparsten Ausdruck zu speichern.
Beispiel
100
julia> :ABC
:ABC
Quotiere den gesamten Ausdruck unten:
Beispiel
:(100 - 50)
Einen arithmetischen Ausdruck quotieren:
Beispiel
:(a + b * c + 1)
julia> typeof(ex)
Expr
Beachten Sie, dass äquivalente Ausdrücke auch mit Meta.parse oder direkt mit Expr konstruiert werden können:
Beispiel
Meta.parse("a + b*c + 1") ==
Expr(:call, :+, :a, Expr(:call, :*, :b, :c), 1)
wahr
Das Quotieren mehrerer Ausdrücke kann auchquote ... endeinen Codeblock darin einschließen.
Beispiel
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
Ausführen von Ausdrücken
Nachdem ein Ausdruck geparst wurde, können wir die Funktion eval() verwenden, um ihn auszuführen:
Beispiel
:(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
Abstrakter Syntaxbaum (AST)
Ein abstrakter Syntaxbaum (AST) ist eine abstrakte Darstellung der grammatikalischen Struktur des Quellcodes.
Er stellt die syntaktische Struktur einer Programmiersprache in Baumform dar; jeder Knoten im Baum repräsentiert eine Struktur im Quellcode.
Wir können die hierarchische Struktur eines Ausdrucks mit der Funktion dump() anzeigen:
Beispiel
Expr
head: Symbol⟦⟧call call
args: Array{Any}((3,))
1: Symbol *
2: Int64 1
3: Expr
head: Symbol⟦⟧call call
args: Array{Any}((2,))
1: Symbol cos
2: Expr
head: Symbol⟦⟧call call
args: Array{Any}((3,))
1: Symbol /
2: Symbol pi
3: Int64 2
Interpolation
Obwohl das direkte Konstruieren von Expr-Objekten mit Wertparametern leistungsfähig ist, kann sich der Expr-Konstruktor im Vergleich zur Julia-Syntax umständlich anfühlen. Als Alternative erlaubt Julia, Literale oder Ausdrücke in quotierte Ausdrücke einzufügen. Ausdrucksinterpolation wird durch das Präfix $ angegeben.
In diesem Beispiel wird der Wert der Variablen a interpoliert:
Beispiel
julia> ex = :($a + b)
:(1 + b)
Das Interpolieren in einen nicht quotierten Ausdruck wird nicht unterstützt, was einen Kompilierzeitfehler verursacht:
julia> $a + b ERROR: syntax: "$" expression outside quote
In diesem Beispiel wird das Tupel (1,2,3) als Ausdruck in den Bedingungstest eingefügt:
julia> ex = :(a in $:((1,2,3)) ) :(a in (1, 2, 3))
Die Verwendung von $ in der Ausdrucksinterpolation erinnert bewusst an String-Interpolation und Befehlsinterpolation. Ausdrucksinterpolation macht die programmatische Konstruktion komplexer Julia-Ausdrücke bequem und lesbar.
Makro
Makros bieten einen Mechanismus, um generierten Code in den finalen Rumpf eines Programms einzubinden. Ein Makro bildet eine Menge von Argumenten auf einen zurückgegebenen Ausdruck ab, und der generierte Ausdruck wird direkt kompiliert, ohne dass ein eval-Aufruf zur Laufzeit erforderlich ist. Makroargumente können Ausdrücke, Literale und Symbole enthalten.
Dies ist ein sehr einfaches Makro:
Beispiel
return :( println("Hello, world!") )
end
@sayhello (Makro mit 1 Methode)
In der Julia-Syntax haben Makros ein Sonderzeichen @ (At-Zeichen), unmittelbar gefolgt von einem eindeutigen Makronamen, der mit der Form macro NAME ... end deklariert wird. In diesem Beispiel ersetzt der Compiler alle @sayhello durch:
:( println("Hello, world!") )
Wenn @sayhello in der REPL eingegeben wird, führt der Interpreter es sofort aus, sodass wir nur das ausgewertete Ergebnis sehen:
julia> @sayhello() Hello, world!
Betrachten wir nun ein etwas komplexeres Makro:
Beispiel
return :( println("Hello, ", $name) )
end
@sayhello (Makro mit 1 Methode)
Dieses Makro akzeptiert ein Argument namens name. Wenn @sayhello angetroffen wird, wird der quotierte Ausdruck expandiert und der Wert des Arguments in den endgültigen Ausdruck eingefügt:
Beispiel
Hello, human
Wir können die Funktion macroexpand verwenden, um den zurückgegebenen quotierten Ausdruck anzuzeigen:
Beispiel
:(Main.println("Hello, ", "human"))
julia> typeof(ex)
Expr
Wir können sehen, dass das Literal "human" in den Ausdruck eingefügt wurde.
Es gibt auch ein Makro @macroexpand, das bequemer sein kann als die Funktion macroexpand:
Beispiel
:(println("Hello, ", "human"))