Metaprogramming: prefer functions with eval or macros?

General Usage
1

In Julia it seems there are two ways one could do code generation within in a package: 1) define a function which calls eval and then call the function within the package module, or 2) define a macro which creates the function. E.g. for a package MyPkg:

module MyPkg
# 1: Function + eval =====================================
function make_a_function(a::String)
  eval(Meta.parse("$(a)() = println(\"Hi I'm $(a)!\")"))
end

make_a_function("matt")

# 2: Macro ===============================================
macro make_a_function(a)
  return :($a() = println("Hi I'm $($a)!"))
end

@make_a_function foo

end

I was wondering which of these methods is “preferred”, if any, or if they are completely equivalent. My instinct tells me the code generation via a macro is certainly done statically, and therefore would be preferred, but perhaps the function + eval is also fully static and so either is ok.

2

Function + eval is definitely not static, it’s done at runtime. That also means it’s typically used for fundamentally different purposes, e.g. evaluating user input interactively, when the desired information is only available at runtime.

Of course, first you should ask yourself whether you should be doing metaprogramming in the first place. It’s a great tool to have a available on occasion, but 99% of the time you should be using ordinary functions and data structures. See also the discussion in: How to warn new users away from metaprogramming

2 Likes
3

The use case is just to ease the generation of code. We could easily get away without any metaprogramming, but it is convenient + makes code maintenance simpler.

So in this case, it seems using a macro would be preferred

4

Saying “I need code generation because I want to generate code” is a bit circular. I agree that there are cases where metaprogramming simplifies things, but if you find yourself generating or writing repetitive code it’s often good to ask whether you could be using generic programming with better abstractions.

But I can’t comment on your particular case, since you haven’t provide any details — just a general observation that metaprogramming should rarely be the first technique you reach towards. This is especially true for people who are new to the language and may not fully understand its abstractions yet.

2 Likes
5

Agreed.