What is metaprogramming in Julia?

Julia is an innovative open-source programming language with strong metaprogramming capabilities and LispList Processing-style macros.

Metaprogramming refers to the ability of a computer program to manipulate itself or treat other programs as its data. Metaprograms are programs that manipulate themselves or other programs. They are designed to read, generate, analyze, or transform other programs and even modify themselves whilst running. 

How Julia's code is represented

Julia's code is internally represented as a data structure that is accessible from within the language itself. Therefore, a program written in Julia can transform and generate its own code.

Julia's raw code is parsed and transformed into data structures of type expressions (Expr).

These expressions can also be constructed using :(...) or quote...end. At this stage, the LLVMLow Level Virtual Machine Just-In-Time (JIT) compiler converts the raw Julia code into a form suitable for evaluation called ASTAbstract Syntax Tree (AST).

The generated expressions can be transformed into other expressions or compiled and executed within the following contexts:

  • Using the eval function at runtime

  • Using macros

  • Using generated functions

Metaprogramming benefits

Metaprogramming provides several benefits including:

  • Optimizes code by performing logic during compilation

  • Performs complex tasks with a simpler syntax

  • Provides code library users with cost-free abstractions

Let's uncover the metaprogramming concept in Julia by running the following examples:

Code example 1

This example shows the use of eval() function:

expr = :(a=2; b=a^2; c = b-a)
println("Evaluating the expression:")
show(expr)
println()
println("The result is:",eval(expr))
println("The hierarchical representation of the expression:")
dump(expr)

Let's go through the code:

  • Line 1: We define an expression composed of several objects.

  • Lines 2–4: We print out the string representation of the defined expression. Remember that the :( ... ) and quote .. end blocks are treated identically.

  • Line 5: We evaluate the expression using the  eval() function and display the result using the println() function.

  • Lines 7–8: We call the dump() function to display an indented and annotated representation of the Expr object.

Code example 2

This example shows how macros work:

macro sumall_macro(counter)
  quote
    local s = 0
    for i = 1:$counter
        s += i
    end
    print(s)
  end  
end
print("The result is:")
@sumall_macro(3)

Let's go through the code:

  • Lines 1–9: We define a macro that uses a for loop to carry out the summation of all values between 1 and the parameter specified as an argument. The summation value is stored in a local variable s.

  • Lines 11–12: We call the macro and print out the result.

Code example 3

This example demonstrates generated functions which are special types of macros that can generate appropriate code depending on their argument types.

@generated function multiply_vars(x,y)
           return :(x * y)
end
println(multiply_vars(3,5))
println(multiply_vars("a","b"))

Let's go through the code:

Note: If integer values are supplied, this function calculates the product (multiplied value) of both parameters, whereas if string values are supplied, this function returns the concatenation of these parameters.

  • Lines 1–3: We define a generated function multiply_vars() that multiplies the arguments specified.

  • Line 4: We call the generated function while specifying two integer values as parameters and display the result.

  • Line 5: We call the generated function while specifying two string values as parameters and display the result.

Free Resources

Copyright ©2026 Educative, Inc. All rights reserved