` expressions, so ` @swap_args(2/3)` gives 1.5 i.e. 3/2
macro swap_args(e)
e.args[2:3] = e.args[3:-1:2]
e
end
@swap_args(2/3)
1.50
```
I will write up a compendium over the next few days and link it at the top of the WikiBook metaprogramming page: [Introducing Julia/Metaprogramming - Wikibooks, open books for an open world](https://en.wikibooks.org/wiki/Introducing_Julia/Metaprogramming).
(EDIT:) Looks like we’re getting a good mix of difficulty levels!
π
---
### Author:  [@JeffreySarnoff](https://discourse.julialang.org/u/JeffreySarnoff)
#### Post date: [December 6, 2016, 3:58am UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/2 "2016-12-06T03:58:20Z")
Maybe call that one `swap_operands` (because `swap(a,b)` is likely `b,a` without the operator) .
---
### Author:  [@dfdx](https://discourse.julialang.org/u/dfdx)
#### Post date: [December 6, 2016, 2:12pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/3 "2016-12-06T14:12:50Z")
Another common macro that I often describe to newcomers is `@time`.
More sophisticated examples of expression transformations may include functions / macros to match expression against pattern or substitute part of expression, e.g.:
```julia
expr = :(num ^ 2)
pattern = :(x ^ n)
matchex(expr, pattern) # ==> Dict(:x => :num, :n => 2)
expr = :(x ^ n)
subs(expr, n=2) # ==> :(x ^ 2)
```
I used these functions extensively in [Espresso.jl](https://github.com/dfdx/Espresso.jl), but I find them a funny exercise metaprogramming as well.
---
### Author:  [@bramtayl](https://discourse.julialang.org/u/bramtayl)
#### Post date: [December 6, 2016, 4:13pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/4 "2016-12-06T16:13:34Z")
Chaining macros? A simple one below:
```julia
link(a, b) = quote
let _ = $a
b
end
end
macro chain(as...) = reduce(link, as)
```
```julia
```
---
### Author:  [@Balinus](https://discourse.julialang.org/u/Balinus)
#### Post date: [December 6, 2016, 6:49pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/5 "2016-12-06T18:49:31Z")
Honestly, I don’t understand any examples here!
edit - By that, I mean I just can’t use these examples into Julia REPL and i feel that this thread would be super useful for beginner’s like me.
---
### Author:  [@stevengj](https://discourse.julialang.org/u/stevengj)
#### Post date: [December 6, 2016, 6:53pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/6 "2016-12-06T18:53:53Z")
One possible example is to generate an inlined polynomial evaluation by Horner’s method, given a variable `x` and a list of coefficients. This is actually implemented in Base (base/math.jl), but makes a good exercise because it is simple and genuinely practical:
```julia
# evaluate p[1] + x * (p[2] + x * (....)), i.e. a polynomial via Horner's rule
macro horner(x, p...)
ex = esc(p[end])
for i = length(p)-1:-1:1
ex = :(muladd(t, $ex, $(esc(p[i]))))
end
Expr(:block, :(t = $(esc(x))), ex)
end
```
---
### Author:  [@mkborregaard](https://discourse.julialang.org/u/mkborregaard)
#### Post date: [December 6, 2016, 8:05pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/7 "2016-12-06T20:05:24Z")
The way I understand @dfdx example, it is a task: implement the matchex and subs macros?
---
### Author:  [@JeffreySarnoff](https://discourse.julialang.org/u/JeffreySarnoff)
#### Post date: [December 6, 2016, 8:33pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/8 "2016-12-06T20:33:31Z")
(imo)
Macro contributors, Balinus and many others need an accompanying example that is easily absorbed and some words about what is happening. A second more recondite example is welcome, too.
---
### Author:  [@dfdx](https://discourse.julialang.org/u/dfdx)
#### Post date: [December 6, 2016, 10:06pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/9 "2016-12-06T22:06:27Z")
Yes, exactly. But you may also find ready-to-use solutions [here](https://github.com/dfdx/Espresso.jl/blob/master/src/core/rewrite.jl). The point of these functions as an exercise is to learn how to efficiently traverse and transform Julia expressions, which opens the doors to all kinds of fun stuff like automatic differentiation, [devectorization](https://github.com/lindahua/Devectorize.jl) or [fast math transformation](https://github.com/JuliaLang/julia/blob/master/base/fastmath.jl).
---
### Author:  [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [December 6, 2016, 10:45pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/10 "2016-12-06T22:45:30Z")
I had a problem earlier today of transforming
```julia
@muladd a1*b1 + a2*b2 + a3*b3 + a4*b4
```
into a statement with `muladd` function calls:
```julia
muladd(a1,b1,muladd(a2,b2,muladd(a3,b3,a4*b4))))
```
credit for the neat solution goes to @fcard on Gitter:
```julia
macro muladd(ex)
@assert ex.head == :call
@assert ex.args != [:+]
@assert ex.args[1] == :+
esc(_muladd_meta(ex))
end
function _muladd_meta(ex)
if length(ex.args) == 2
return ex.args[2]
else
a, b = ex.args[2].args[2:end]
rest = _muladd_meta(Expr(ex.head, :+, ex.args[3:end]...))
return :($(Base.muladd)($a, $b, $rest))
end
end
```
This is a good little example of a syntactic sugar macro which can be quite useful for performance.
---
### Author:  [@bramtayl](https://discourse.julialang.org/u/bramtayl)
#### Post date: [December 7, 2016, 1:35am UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/11 "2016-12-07T01:35:44Z")
Here’s another implementation of muladd using packages to make things pretty?
```julia
using MacroTools
using ChainMap
muladd_(e) = @match e begin
+(a_*b_) => Expr(:call, :*, a, b)
+(a_*b_, c__) => muladd_together(a, b, c)
end
muladd_together(a, b, c) = @chain begin
Expr(:call, :+, c...)
muladd_
Expr(:call, Base.muladd, a, b, _)
end
macro muladd(e)
muladd_(e)
end
```
---
### Author:  [@fcard](https://discourse.julialang.org/u/fcard)
#### Post date: [December 7, 2016, 2:10am UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/12 "2016-12-07T02:10:15Z")
Once again one of my macros was stricken with MacroTools… A bit of my soul dies each time. (jkjkjk!)
Personally I prefer to use julia’s own abstractions to make things “pretty”:
```julia
macro muladd(add)
esc(to_muladd(add))
end
function to_muladd(add)
let mul = operands(add)[1]
if length(operands(add)) == 1
return mul
else
a, b = operands(mul)
rest = to_muladd(:( +($(operands(add)[2:end]...)) ))
return :($(Base.muladd)($a, $b, $rest))
end
end
end
operator(ex) = ex.args[1]
operands(ex) = ex.args[2:end]
```
Here is the dumb thing + error handling and tests: [https://gist.github.com/fcard/12a49827cc26a197d4d1e75481216176](https://gist.github.com/fcard/12a49827cc26a197d4d1e75481216176)
All valid ways of doing the same thing, of course.
---
### Author:  [@mtsch](https://discourse.julialang.org/u/mtsch)
#### Post date: [December 7, 2016, 7:43am UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/13 "2016-12-07T07:43:58Z")
For a simple, but fun exercise, try writing a macro that turns expressions into anonymous functions, using `_` as arguments. An example of the macro being used would be:
```julia
map(@par(_ * max(_, 2)), 1:4, 4:-1:1)
# 4 6 6 8
```
Another thing you could try is adding an option of labeling the `_` arguments with numbers, making `_1` the first argument, `_2` the second and so on. You could also add type annotations.
---
### Author:  [@MikeInnes](https://discourse.julialang.org/u/MikeInnes)
#### Post date: [December 7, 2016, 11:24am UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/14 "2016-12-07T11:24:32Z")
Well hey, if we’re macro-golfing:
```julia
macro muladd(ex)
foldr((a, b) -> :(muladd($(a.args[2:end]...), $b)), ex.args[2:end])
end
```
As another starting out idea, here’s the simplest thing I can think of that isn’t equivalent to a closure:
```julia
(a, b) = (1, 2)
@swap a b
(a, b) == (2, 1)
```
Should be pretty easy for a beginner to write.
---
### Author:  [@MikeInnes](https://discourse.julialang.org/u/MikeInnes)
#### Post date: [December 7, 2016, 12:36pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/15 "2016-12-07T12:36:07Z")
Here’s a harder variation on the muladd challenge: Make it general enough that it can look at any code and transform the inner muladds, keeping everything else the same. Here’s a version using MacroTools; consider me very impressed if anyone can make it cleaner without 🙂
```julia
macro muladd(ex)
MacroTools.prewalk(ex) do ex
@capture(ex, +(x_ * y_, cs__)) || return ex
:(Base.muladd($x, $y, $(foldl((a,b)->:($b+$a), cs))))
end |> esc
end
a = a1*b1 + a2*b2 + a3*b3
b = a4*b4 + f(a*b + c)
# becomes
a = muladd(a1,b1,muladd(a3,b3,a2 * b2))
b = muladd(a4,b4,f(muladd(a,b,c)))
```
---
### Author:  [@fcard](https://discourse.julialang.org/u/fcard)
#### Post date: [December 7, 2016, 3:05pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/16 "2016-12-07T15:05:25Z")
```julia
macro muladd(ex)
esc(to_muladd(ex))
end
function to_muladd(ex)
is_add_operation(ex) || return ex
operands = collect(zip(
to_muladd.((x->x.args[2]).(ex.args[2:end])),
to_muladd.((x->x.args[3]).(ex.args[2:end]))))
last_operation = :($(operands[end][1]) * $(operands[end][2]))
foldr(last_operation, operands[1:end-1]) do xs, r
:($(Base.muladd)($(xs[1]), $(xs[2]), $r))
end
end
is_add_operation(ex::Expr) = ex.head == :call && !isempty(ex.args) && ex.args[1] == :+
is_add_operation(ex) = false
```
?
Of couse I could make this more compact, but I don’t think code golf was ever the point of this. It’s not about the golf, Mike, it’s about the _love_! (I don’t know what that means)
Nice one with the `foldl` tho, I keep missing the opportunities to use that 😛
* * *
**Edit** : I added this new functionality to the gist of my no-fun version , which I still like despite the hardships we encountered together.
**Edit2** : It has dawned on me that we may have gone off topic a bit, I will see if I can come up with a few simple macros to make up for it.
* * *
> Mike Innes really is the He-Man to my Skeletor, I keep trying to take over ~~Eternia~~ Julia by introducing my evil verbosity and taking away all the fun, but he keeps foiling my dastardly plans through the power of ~~Grayskull~~ CodeGolfing.
---
### Author:  [@mkborregaard](https://discourse.julialang.org/u/mkborregaard)
#### Post date: [March 7, 2017, 4:19pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/17 "2017-03-07T16:19:30Z")
> [@stevengj](#):
>
> ```julia
> macro horner(x, p...)
> ex = esc(p[end])
> for i = length(p)-1:-1:1
> ex = :(muladd(t, $ex, $(esc(p[i]))))
> end
> Expr(:block, :(t = $(esc(x))), ex)
> end
>
> ```
This is really a great example, because of the cool ways it uses interpolations and escaping. It could be really useful for macro learners, I think, with a line-by-line description of the construction and considerations.
---
### Author:  [@cscherrer](https://discourse.julialang.org/u/cscherrer)
#### Post date: [January 6, 2018, 3:18pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/18 "2018-01-06T15:18:40Z")
Transform a vector of symbols into a symbol of tuples:
`tuplify([:a,:b]) == :((a,b))`
My solution works, but it feels a bit kludgy:
```julia
function tuplify(x)
a = Expr(:tuple, x)
a.args = x
a
end
```
---
### Author:  [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)
#### Post date: [January 6, 2018, 3:53pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/19 "2018-01-06T15:53:34Z")
```julia
julia> t = [:a, :b];
julia> :(($(t...),))
:((a, b))
```
---
### Author:  [@cscherrer](https://discourse.julialang.org/u/cscherrer)
#### Post date: [January 6, 2018, 3:54pm UTC](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731/20 "2018-01-06T15:54:28Z")
> [@Tamas\_Papp](#):
>
> julia\> :(($(t…),))
> :((a, b))
Oh that’s much better, thanks!
[Next page](https://discourse.julialang.org/t/simple-metaprogramming-exercises-challenges/731.md?page=2)