# Julia Programming - Metaprogramming

Metaprogramming may be defined as the programming in which we write Julia code to process and modify Julia code. With the help of Julia metaprogramming tools, one can write Julia programming code that modifies other parts of the source code file. These tools can even control when the modified code runs.

Following are the execution stages of raw source code −

### Stage 1 − Raw Julia code is parsed

In this stage the raw Julia code is converted into a form suitable for evaluation. The output of this stage is AST i.e. Abstract Syntax Tree. AST is a structure which contains all the code in an easy to manipulate format.

### Stage 2 − Parsed Julia code is executed

In this stage, the evaluated Julia code is executed. When we type code in REPL and press Return the two stages happens but they happen so quickly that we don’t even notice. But with metaprogramming tools we can access the Julia code between two stages, i.e. after code parsed but before its evaluation.

## Quoted expressions

As we discussed, with metaprogramming we can access the Julia code between two stages. For this, Julia has ‘:’ colon prefix operator. With the help of colon operator, Julia store an unevaluated but parsed expression.

### Example

   julia> ABC = 100
100

julia> :ABC
:ABC


Here, − ABC is quoted or unevaluated symbol for Julia i.e. ‘ABC ‘ is an unevaluated symbol rather than having the value 100.

We can quote the whole expressions as below −

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


Alternatively, we can also use quote…end keywords to enclose and quote an expression as follows −

julia> quote
100 - 50
end
quote
#= REPL[43]:2 =#
100 - 50
end
Check this also:
julia> expression = quote
for x = 1:5
println(x)
end
end
quote
#= REPL[46]:2 =#
for x = 1:5
#= REPL[46]:3 =#
println(x)
end
end

julia> typeof(expression)
Expr


It shows that expression object is parsed, primed and ready to use.

## Evaluated expressions

Once you parsed the expression, there is a way to evaluate the expression also. We can use the function eval() for this purpose as follows −

julia> eval(:ABC)
100

julia> eval(:(100-50))

50

julia> eval(expression)
1
2
3
4
5


In the example, we have evaluated the expressions parsed in above section.

## The Abstract Syntax Tree (AST)

As discussed above, Abstract Syntax Tree (AST) is a structure which contains all the code in an easy to manipulate format. It is the output of stage1. It allows us to easily process and modify the Julia code. We can visualize the hierarchical nature of an expression with the help of dump() function.

### Example

julia> dump(:(1 * cos(pi/2)))
Expr
args: Array{Any}((3,))
1: Symbol *
2: Int64 1
3: Expr
args: Array{Any}((2,))
1: Symbol cos
2: Expr
args: Array{Any}((3,))
1: Symbol /
2: Symbol pi
3: Int64 2


## Expression interpolation

Any Julia code which has string or expression is usually unevaluated but with the help of dollar ($) sign (string interpolation operator), we can evaluate some of the code. The Julia code will be evaluated and inserts the resulting value into the string when the string interpolation operator is used inside a string. ### Example julia> "the cosine of 1 is$(cos(1))"
"the cosine of 1 is 0.5403023058681398"


Similarly, we can use this string interpolation operator to include the results of executing Julia code interpolated into unevaluated expression −

julia> quote ABC = $(cos(1) + tan(1)); end quote #= REPL[54]:1 =# ABC = 2.097710030523042 end  ## Macros We are now aware of creating and handling unevaluated expressions. In this section, we will understand how we can modify them. Julia provides macro that accepts an unevaluated expression as input and generates a new output expression. If we talk about its working, Julia first parses and evaluates the macro, and then the processed code produced by macro will be evaluated like an ordinary expression. The syntax of defining a macro is very similar to that of a function. Following is the definition of macro that will print out the contents of the things we pass to it − julia> macro x(n) if typeof(n) == Expr println(n.args) end return n end @x (macro with 1 method)  We can run the macros by preceding the name of the macro with the @ prefix − julia> @x 500 500 julia> @x "Tutorialspoint.com" "Tutorialspoint.com" eval() and @eval  Julia has eval() function and a macro called @eval. Let us see example to know their differences − julia> ABC = :(100 + 50) :(100 + 50) julia> eval(ABC) 150  The above output shows that the eval() function expands the expression and evaluates it. julia> @eval ABC :(100 + 50) julia> @eval$(ABC)
150


It can also be treated as follows −

julia> @eval \$(ABC) == eval(ABC)
true


## Expanding Macros

The macroexpand() function returns the expanded format (used by the Julia compiler before it is finally executed) of the specified macro.

### Example

julia> macroexpand(Main, quote @p 1 + 4 - 6 * 7 / 8 % 9 end)
Any[:-, :(1 + 4), :(((6 * 7) / 8) % 9)]
quote
#= REPL[69]:1 =#
(1 + 4) - ((6 * 7) / 8) % 9
end