Return handles to functions from caller-namespace from a macro

General Usage
1

I have made a minimal working example of a macro that returns a list of handles for the functions it receives as input. Obviously this can be achieved more easily without a macro, but let us assume there is a more complicated task where I need a macro to be able to return working function handles in some data structure. The handles do not have to work inside the macro itself, but they shall point to the respective function in the caller namespace after evaluation.

Macro demo

using MacroTools
macro fun_demo(ex)
    return [eval(x) for x in rmlines(ex).args]
end

Example use

f(x)=x
g(x)=x²
@fun_demo begin
    f
    g
end

Example output

2-element Vector{Function}:
 f (generic function with 1 method)
 g (generic function with 1 method)

The question
The problem with the implementation is, that (a) you are not supposed to use eval inside a macro and (of more practical importance) (b) it will not work anymore if the macro is inside a module because the functions are not known inside the module.
Thus my question is: How would you achieve the same outcome as above with cleaner code and most importantly in a way that works from within a module?

Some ideas / things i have tried
I have been playing with “esc” without any working results. I could also imagine that instead of returning the vector of function handles directly, you need to return an expression that will generate the vector of function handles once it is returned & evaluated at the call site - but I do not know how to pull it off. A simple “solution” would also be to just return the symbols and then have some external function “instantiate_function_handles” that you have to call on the resulting vector… But this also seems unelegant and requires the user of the macro to call a helper function on top of the macro.

2

I’m not entirely sure which context you want to use this in, but something like this:

macro fun_demo(funs...)
    return Expr(:vect, funs...) |> esc
end

julia> @fun_demo sin cos
2-element Vector{Function}:
 sin (generic function with 14 methods)
 cos (generic function with 14 methods)
3

The idea here is to look at what kind of Expr creates a vector:

julia> dump(:([sin, cos]))
Expr
  head: Symbol vect
  args: Array{Any}((2,))
    1: Symbol sin
    2: Symbol cos

An Expr takes the head argument, the rest forms a vector of arguments, which in our case are symbols. So the macro should construct an Expr(:vect, ...list of symbols...). These symbols are in the input funs..., or you may create them in some other fashion. So Expr(:vect, funs...) does the trick. Then pipe it through esc so the macro sanitizer does not add module names and stuff.

Alternatively you can create the Expr iteratively:

macro fun_demo(funs...)
    ex = :([])
    for f in funs
        push!(ex.args, f)
    end
    return ex |> esc    
end
4

Thanks, basically this is doing the job.
I added a version a bit closer to my original example and with a module to show that it works:

module FunDemo3
    using MacroTools
    macro fun_demo3(ex)
        return Expr(:vect, rmlines(ex).args...) |> esc
    end
    export @fun_demo3
end

using .FunDemo3
f(x)=x
g(x)=x²
@fun_demo3 begin
    f
    g
end