Julia Metaprogramming

Julia represents its own code as data structures in the language, so that we can write programs that manipulate programs.

Metaprogramming can also be simply understood as writing code that can generate code.

Metaprogramming refers to the writing of a certain class of computer programs that write or manipulate other programs (or themselves) as their data, or that accomplish at compile time part of the work that should have been done at runtime. In most cases, compared with writing all code by hand, programmers can achieve higher work efficiency, or give the program greater flexibility to handle new situations without recompiling.

The language used to write metaprograms is called the metalanguage. The language of the program being manipulated is called the "target language". The ability of a programming language to also be its own metalanguage is called "reflection" or "reflexivity".

-- Wikipedia

Julia Source Code Execution Stages

1. Parse the original Julia code: The Julia parser first parses the string to obtain an abstract syntax tree (AST), which is a structure that contains all the code in an easy-to-manipulate format.

2. Execute the parsed Julia code:: In this stage, the parsed Julia code is executed.

When we enter code in the interactive programming environment (REPL) and press Enter, the above two stages are executed.

With metaprogramming tools, we can access the Julia code between these two stages, that is, after the source code is parsed but before it is executed.

Program Representation

Julia provides a Meta module, in which Meta.parse(str) can be used to parse a string, and typeof(e1) returns Expr:

Returns:(1 + 1)The returned value consists of a colon and the following expression; typeof(ex1) returns Expr.

The Expr object contains two parts (ex1 contains the head and args attributes):

One is a symbol object that identifies the type of the expression.

The other is the arguments of the expression, which may be symbols, other expressions, or literals:

Expressions can also be constructed directly with Expr:

The two expressions constructed above, one by parsing and one by direct construction, are equivalent:

Expr objects can also be nested:

We can also use Meta.show_sexpr to view expressions. The following example demonstrates nested Expr:

Symbols

We can use the colon:prefix operator to store an unevaluated but parsed expression.

Quote the entire expression below:

Quote an arithmetic expression:

Note that equivalent expressions can also be constructed using Meta.parse or directly with Expr:

Quoting multiple expressions can alsoquote ... endinclude a code block in it.

Executing Expressions

After an expression is parsed, we can use the eval() function to execute it:

Abstract Syntax Tree (AST)

An abstract syntax tree (AST) is a structure that is an abstract representation of the grammatical structure of source code.

It represents the syntactic structure of a programming language in tree form; each node on the tree represents a structure in the source code.

We can view the hierarchical structure of an expression with the dump() function:

Interpolation

Although constructing Expr objects directly with value parameters is powerful, compared with Julia syntax, the Expr constructor may feel tedious. As an alternative, Julia allows literals or expressions to be inserted into quoted expressions. Expression interpolation is indicated by the prefix $.

In this example, the value of variable a is interpolated:

Interpolating into an unquoted expression is not supported, which causes a compile-time error:

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

In this example, the tuple (1,2,3) is inserted as an expression into the conditional test:

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

The use of $ in expression interpolation is deliberately reminiscent of string interpolation and command interpolation. Expression interpolation makes the programmatic construction of complex Julia expressions convenient and readable.

Macro

Macros provide a mechanism for including generated code in the final body of a program. A macro maps a set of arguments to a returned expression, and the generated expression is compiled directly without requiring a runtime eval call. Macro arguments may include expressions, literals, and symbols.

This is a very simple macro:

In Julia's syntax, macros have a special character @ (at-sign), immediately followed by a unique macro name declared using the form macro NAME ... end. In this example, the compiler will replace all @sayhello with:

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

When @sayhello is entered in the REPL, the interpreter executes it immediately, so we only see the evaluated result:

julia> @sayhello()
Hello, world!

Now, consider a slightly more complex macro:

This macro accepts an argument name. When @sayhello is encountered, the quoted expression is expanded and the value of the argument is inserted into the final expression:

We can use the macroexpand function to view the returned quoted expression:

We can see that the literal "human" has been inserted into the expression.

There is also a macro @macroexpand, which may be more convenient than the macroexpand function: