Engee documentation
Notebook

Macros in Julia: A powerful metaprogramming tool

Macro is a metaprogramming tool that allows you to write code that generates other code. This is a kind of "program for programs" that runs at the pre-compilation stage, automatically inserting pre-prepared code fragments into the specified location.

Metaprogramming is the technique of writing programs that can generate or modify other code at runtime. In Julia, this feature is implemented through a system of macros that provide powerful tools for creating expressive and effective code.

Macros in Julia work at the level of an abstract syntax tree (AST), allowing you to transform code before it is compiled. This distinguishes them from functions that operate with calculated values at runtime.

How macros work

Macros are defined using a keyword macro and accept expressions as arguments. They return Expr (expression), which is then evaluated:

macro name(arguments)
    #
return quote code generation
        # generated code
    end
end

One of the key features of macros is hygiene, it's not about hand cleanliness, but about code cleanliness and avoiding name conflicts. Variables created inside a macro do not conflict with variables in the external scope by default. This is achieved using the function esc() which disables hygiene for specific expressions when necessary.

In addition to the above operators, macros also contain several more code structures.:

  • quote...end creates a block of code
  • $(expression) interpolates values into the generated code
  • string(expr) converts an expression to a string for debugging

Analysis of the macros presented

The macro @p — simple output of values

This macro demonstrates the basic principle: intercepting an expression, calculating it, and outputting the result without disrupting the flow of execution.

In [ ]: 
macro p(expr)
    return quote
        value = $(esc(expr))
        display(value)
        value
    end
end

# Использование:
@p x = sin(2)
@p "Engee"
x

0.9092974268256817
"Engee"
Out[0]:
0.9092974268256817

The macro @debug — debugging output

A more complex example that shows how you can capture the string representation of an expression for understandable debugging messages.

In [ ]: 
macro debug(expr)
    expr_str = string(expr)
    return quote
        local result = $(esc(expr))
        println($expr_str, " = ", result)
        result
    end
end

# Использование:
@debug 2 + 3 * 4
@debug sin(π/2);

2 + 3 * 4 = 14
sin(π / 2) = 1.0
Out[0]:
1.0

The macro @test_quick — minimalistic testing

It illustrates how to work with multiple arguments and how to organize a simple assertions system.

In [ ]: 
macro test_quick(expr, expected)
    return quote
        local result = $(esc(expr))
        local expected_val = $(esc(expected))
        if result == expected_val
            println("✓ Тест пройден: ", $(string(expr)), " == ", expected_val)
        else
            println("✗ Тест не пройден: ", $(string(expr)), " = ", result, ", ожидалось: ", expected_val)
        end
        result
    end
end

# Использование:
@test_quick 2+2 4
@test_quick length("hello") 3;

✓ Тест пройден: 2 + 2 == 4
✗ Тест не пройден: length("hello") = 5, ожидалось: 3
Out[0]:
5

The macro @safe — safe execution

It shows error handling at the macro level, which allows you to create elegant wrappers for potentially dangerous operations.

In [ ]: 
macro safe(expr)
    return quote
        try
            local result = $(esc(expr))
            println("Успех: ", result)
            result
        catch e
            println("Ошибка: ", e)
            nothing
        end
    end
end

# Использование:
@safe 1/0
@safe parse(Int, "не число")

Успех: Inf
Ошибка: ArgumentError("invalid base 10 digit 'н' in \"не число\"")

The macro @benchmark — performance

The most complex macro that demonstrates the possibilities of measuring execution time, statistical processing of results, and returning useful data.

In [ ]: 
macro benchmark(n, expr)
    return quote
        local times = Float64[]
        local results = []
        
        for i in 1:$(esc(n))
            local start = time()
            local result = $(esc(expr))
            local elapsed = time() - start
            push!(times, elapsed)
            push!(results, result)
        end
        
        local avg_time = sum(times) / length(times)
        local min_time = minimum(times)
        local max_time = maximum(times)
        
        println("Запусков: ", $(esc(n)))
        println("Среднее: ", round(avg_time; digits=6), "s")
        println("Минимум: ", round(min_time; digits=6), "s")
        println("Максимум: ", round(max_time; digits=6), "s")
        
        results[end]
    end
end

# Использование:
@benchmark 1000 sin.(rand(10000));

Запусков: 1000
Среднее: 0.000645s
Минимум: 0.000125s
Максимум: 0.315429s

Conclusion

Macros are one of the most powerful tools in the Julia programmer's arsenal. They allow you not only to write more expressive code, but also to expand the capabilities of the language, adapting it to specific tasks. The macros presented in this example demonstrate a range of possibilities — from simple debugging to complex benchmarking, opening the way to creating your own specialized tools.