Метапрограммирование в Julia
Julia представляет свой собственный код как структуры данных в языке, так что мы можем писать программы, которые манипулируют программами.
Метапрограммирование также можно просто понимать как написание кода, который может генерировать код.
Метапрограммирование — это написание определённого класса компьютерных программ, которые пишут или манипулируют другими программами (или самими собой) как своими данными, либо выполняют на этапе компиляции часть работы, которая должна была выполняться во время выполнения. В большинстве случаев по сравнению с написанием всего кода вручную программисты могут достичь более высокой эффективности работы или придать программе большую гибкость для обработки новых ситуаций без перекомпиляции.
Язык, используемый для написания метапрограмм, называется метаязыком. Язык программы, которой манипулируют, называется «целевым языком». Способность языка программирования также быть своим собственным метаязыком называется «рефлексией» или «рефлексивностью».
— Википедия
Этапы выполнения исходного кода Julia
1. Разбор исходного кода Julia: Сначала парсер Julia разбирает строку, чтобы получить абстрактное синтаксическое дерево (AST) — структуру, которая содержит весь код в удобном для манипулирования формате.
2. Выполнение разобранного кода Julia:: На этом этапе выполняется разобранный код Julia.
Когда мы вводим код в интерактивной среде программирования (REPL) и нажимаем Enter, выполняются два вышеуказанных этапа.
С помощью инструментов метапрограммирования мы можем получить доступ к коду Julia между этими двумя этапами, то есть после разбора исходного кода, но до его выполнения.
Представление программы
Julia предоставляет модуль Meta, в котором Meta.parse(str) можно использовать для разбора строки, а typeof(e1) возвращает Expr:
Пример
"1 + 1"
julia> ex1 = Meta.parse(prog)
:(1 + 1)
julia> typeof(ex1)
Expr
Возвращает:(1 + 1)Возвращаемое значение состоит из двоеточия и следующего выражения; typeof(ex1) возвращает Expr.
Объект Expr содержит две части (ex1 содержит атрибуты head и args):
Одна — это символьный объект, который определяет тип выражения.
Пример
:call
Другая — это аргументы выражения, которые могут быть символами, другими выражениями или литералами:
Пример
3-элементный Vector{Any}:
:+
1
1
Выражения также можно создавать напрямую с помощью Expr:
Пример
:(1 + 1)
Два выражения, созданные выше, одно путём синтаксического разбора, а другое путём прямого конструирования, эквивалентны:
Пример
истина
Объекты Expr также могут быть вложенными:
Пример
:((4 + 4) / 2)
Мы также можем использовать Meta.show_sexpr для просмотра выражений. Следующий пример демонстрирует вложенный Expr:
Пример
(:call, :/, (:call, :+, 4, 4), 2)
Символы
Мы можем использовать двоеточие:как префиксный оператор, чтобы сохранить невычисленное, но разобранное выражение.
Пример
100
julia> :ABC
:ABC
Заключите в кавычки всё выражение ниже:
Пример
:(100 - 50)
Процитируйте арифметическое выражение:
Пример
:(a + b * c + 1)
julia> typeof(ex)
Expr
Обратите внимание, что эквивалентные выражения также можно построить с помощью Meta.parse или напрямую с Expr:
Пример
Meta.parse("a + b*c + 1") ==
Expr(:call, :+, :a, Expr(:call, :*, :b, :c), 1)
истина
Цитирование нескольких выражений также можетquote ... endвключать в себя блок кода.
Пример
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
Выполнение выражений
После синтаксического разбора выражения мы можем использовать функцию eval() для его выполнения:
Пример
:(1 + 2)
julia> eval(ex1)
3
julia> ex = :(a + b)
:(a + b)
julia> eval(ex)
ОШИБКА: UndefVarError: b не определена
[...]
julia> a = 1; b = 2;
julia> eval(ex)
3
Абстрактное синтаксическое дерево (AST)
Абстрактное синтаксическое дерево (AST) — это структура, которая представляет собой абстрактное представление грамматической структуры исходного кода.
Оно представляет синтаксическую структуру языка программирования в виде дерева; каждый узел на дереве представляет структуру в исходном коде.
Мы можем просмотреть иерархическую структуру выражения с помощью функции dump():
Пример
Expr
head: Symbol call
args: Array{Any}((3,))
1: Символ *
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: Символ /
2: Symbol pi
3: Int64 2
Интерполяция
Хотя создание объектов Expr напрямую с параметрами-значениями является мощным средством, по сравнению с синтаксисом Julia конструктор Expr может казаться утомительным. В качестве альтернативы Julia позволяет вставлять литералы или выражения в выражения, заключённые в кавычки. Интерполяция выражений обозначается префиксом $.
В этом примере интерполируется значение переменной a:
Пример
julia> ex = :($a + b)
:(1 + b)
Интерполяция в выражение без кавычек не поддерживается, что приводит к ошибке времени компиляции:
julia> $a + b ERROR: syntax: "$" expression outside quote
В этом примере кортеж (1,2,3) вставляется как выражение в условную проверку:
julia> ex = :(a in $:((1,2,3)) ) :(a in (1, 2, 3))
Использование $ в интерполяции выражений намеренно напоминает интерполяцию строк и интерполяцию команд. Интерполяция выражений делает программное построение сложных выражений Julia удобным и читаемым.
Макрос
Макросы предоставляют механизм включения сгенерированного кода в окончательное тело программы. Макрос отображает набор аргументов в возвращаемое выражение, и сгенерированное выражение компилируется напрямую без необходимости вызова eval во время выполнения. Аргументы макроса могут включать выражения, литералы и символы.
Это очень простой макрос:
Пример
return :( println("Hello, world!") )
end
@sayhello (макрос с 1 методом)
В синтаксисе Julia макросы имеют специальный символ @ (знак «at»), сразу за которым следует уникальное имя макроса, объявленное с использованием формы macro NAME ... end. В этом примере компилятор заменит все @sayhello на:
:( println("Hello, world!") )
Когда @sayhello вводится в REPL, интерпретатор выполняет его немедленно, поэтому мы видим только вычисленный результат:
julia> @sayhello() Hello, world!
Теперь рассмотрим немного более сложный макрос:
Пример
return :( println("Hello, ", $name) )
end
@sayhello (макрос с 1 методом)
Этот макрос принимает аргумент name. Когда встречается @sayhello, квотированное выражение раскрывается, и значение аргумента подставляется в итоговое выражение:
Пример
Hello, human
Мы можем использовать функцию macroexpand, чтобы просмотреть возвращённое квотированное выражение:
Пример
:(Main.println("Hello, ", "human"))
julia> typeof(ex)
Expr
Мы видим, что литерал "human" был вставлен в выражение.
Также есть макрос @macroexpand, который может быть удобнее, чем функция macroexpand:
Пример
:(println("Hello, ", "human"))