Transformations

The code transformation is the key process of meta programming. Expronicon also provides a set of functions to help you make your own transformations.

Substitution

We provide a Substitute type to help you make substitution, first you can create a Substitute object with a function that describes what should be substituted

julia> sub = Substitute() do expr
           expr isa Symbol && expr in [:x] && return true
           return false
       end;

then you can call this object with another function describes what to substitute with if matched.

julia> sub(_->1, :(x + y))
:(1 + y)

Create similar expressions using nexprs

It is common that one wants to create a block of similar expressions, for example you want to unroll a loop program manually, nexprs can help you here

julia> nexprs(5) do k
           :(1 + \$k)
       end
quote
    1 + 1
    1 + 2
    1 + 3
    1 + 4
    1 + 5
end

Create large code blocks using expr_map

It is common that one wants to create a Expr(:block) with a large number of expressions and each expression is created based on different conditions, instead of writing

ret = Expr(:block)
for i in 1:10
    push!(ret.args, :(1 + $i))
end
return ret

you can use expr_map to do this to save you some typing

expr_map(1:10) do i
    :(1 + $i)
end

Renumber gensyms

Renumber gensyms to have a more deterministic output is very useful when writing expression related tests, renumber_gensym can help you do this by renumber gensym by recounting the number of gensyms in given expression (usually a function body)

julia> renumber_gensym(:(function f()
                  $(gensym(:x)) = 1
                  $(gensym(:x)) = 2
              end))
:(function f()
      #= REPL[3]:1 =#
      #= REPL[3]:2 =#
      var"##x#1" = 1
      #= REPL[3]:3 =#
      var"##x#2" = 2
  end)

Aliasing gensyms

Sometimes you want to alias a gensym to a name for better readability, this idea is borrowed originally from the MacroTools package, alias_gensym will remove #<name>#<id> like gensym with <name>_<id>.

Remove annotations

Sometimes you want to remove type annotations from an expression, rm_annotations can help you do this. It will remove the type annotations from the expression.

Only give me the names

It is quite often that you only want the names of the variables in an expression, name_only will remove everything else but a Symbol.

julia> using Expronicon

julia> name_only(:(sin(2)))
:sin

julia> name_only(:(Foo{Int}))
:Foo

julia> name_only(:(Foo{Int} <: Real))
:Foo

julia> name_only(:(x::Int))
:x

Remove single block expression

To get better readability, sometimes you want to remove the single block like

begin
    x = 1
end

and turn it into

x = 1

rm_single_block can help you do this.

Flatten block expressions

It can be hard to read if you have a nested block expression like

begin
    begin
        x = 1
    end

    y = 2
end

or even more nested, flatten_block can help you flatten the block expression to make it easier to read.