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

julia> prog = "1 + 1"
"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

julia> ex1.head
:call

Das andere sind die Argumente des Ausdrucks, die Symbole, andere Ausdrücke oder Literale sein können:

Beispiel

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

Ausdrücke können auch direkt mit Expr konstruiert werden:

Beispiel

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

Die beiden oben konstruierten Ausdrücke, einer durch Parsen und einer durch direkte Konstruktion, sind äquivalent:

Beispiel

julia> ex1 == ex2
wahr

Expr-Objekte können auch verschachtelt sein:

Beispiel

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

Wir können auch Meta.show_sexpr verwenden, um Ausdrücke anzuzeigen. Das folgende Beispiel demonstriert verschachtelte Expr:

Beispiel

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

Symbole

Wir können den Doppelpunkt-:Präfixoperator verwenden, um einen nicht ausgewerteten, aber geparsten Ausdruck zu speichern.

Beispiel

julia> ABC = 100
100

julia> :ABC
:ABC

Quotiere den gesamten Ausdruck unten:

Beispiel

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

Einen arithmetischen Ausdruck quotieren:

Beispiel

julia> ex = :(a+b*c+1)
:(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

julia>      :(a + b*c + 1)       ==
       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

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

Ausführen von Ausdrücken

Nachdem ein Ausdruck geparst wurde, können wir die Funktion eval() verwenden, um ihn auszuführen:

Beispiel

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

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

julia> dump(:(1 * cos(pi/2)))
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> a = 1;

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

julia> macro sayhello()
           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

julia> macro sayhello(name)
 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

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

Wir können die Funktion macroexpand verwenden, um den zurückgegebenen quotierten Ausdruck anzuzeigen:

Beispiel

julia> ex = macroexpand(Main, :(@sayhello("human")) )
:(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

julia> @macroexpand @sayhello "human"
:(println("Hello, ", "human"))
Andere Erweiterungen