Macro to provide timing for a function call - handle any signature

A very simple question: what does the expanded macro code look like? This might help understanding what is going on. Btw I don’t know.

Thanks for your interest and attempt to help

Doing this for the above example: quoted |> Macro.expand(__ENV__) |> Macro.to_string |> IO.puts
I get:

def double(x) do
  Timer.wrap_timed(
    fn x -> x + x end,
    [x],
    :double
  )
end

The problem I have does not immediately relate to the generated AST.
Rather it relates to the first parameter to the macro: {name, _meta, args} = _ast

The args is a representation of the formal arguments to the function (including simple arguments, keylist, optionals, guards and pattern-matches), but in a form that cannot immediately be unquoted back into a form that is syntactically correct in the context of an Elixir function-definition.

Rather it contains a bunch of meta-data scattered out through the structure. So, what I’ve been looking for - specifically - is a robust way to transform args to a syntactically valid form.
However, I recognise, that I may be attacking the problem the wrong way, so I attempted to state the problem in a form that was open to other solutions.

I’m honestly don’t think this is a solved problem largely for the reasons you note: the forms the AST can take are quite varied. While Elixir does give you the ability to manipulate AST directly, it doesn’t give you many nice helpers like Macro.find_the_do_block_in_this_ast/1.

(I’m speculating here, but I imagine it’s because the AST is an implementation detail subject to change.)

My personal experience with writing macros is that you’re on your own somewhat. The Meta-Programming chapters of the docs are quite good. But for specific applications, you often need to dig in and see what the expressions you plan to work with happen to come out as in AST form.

Note: another snag you’ll hit is that there are other blocks that come after the do block:

def reciprocal(x) when is_integer(x) do
  1 / x
rescue
  ArithmeticError -> :infinity
end

This is very helpful information. Thank you.

I will abandon the project and find a more appropriate way to arrive at my destination.
Thanks again

Couldn’t you just re-use the function signature as-is and then wrap the body in an anonymous function and simply close over the arguments?

Like:

def double(x) do
  Timer.wrap_timed(fn ->
    x + x
  end)
end

BTW you should look into :timer.tc/1.

Just to clarify: I think the approach will work once you cover all the edge cases. I was mostly pushing back on this:

However I agree with @garrison. For most instances when I’ve needed to time functions, it was either for a one time thing or as part of a benchmarking effort.

• For one time use: :timer.tc/{1,2,3}
• For benchmarking: Benchee — Benchee v1.5.1

Looking back at my reply I now see it was ambiguous, so just to clarify: the snippet I posted was meant to be the macro output. I was suggesting it would be easier to write a macro which makes no attempt to pass its arguments through the anonymous function and instead just closes over them.

Then the “edge cases” shouldn’t be so hard as the final “def” call will be almost exactly the same as your “deftimed” except you just wrap a bit of the AST in a fn -> unquote(...) end block.

I do agree the use-case here is a bit strange but sometimes people do things just to experiment so I won’t judge

Ah got it. Yeah agreed a closure would probably be easier to implement since you can just change :def_timer to :def and wrap the do block. (I think there is still the edge case of the after block but no one uses those so who cares. )

Honestly I forgot def even supported more blocks, I don’t think I’ve ever seen any of them used.

Another approach would be to mangle the function name and then generate another one which wraps it with the Timer call. Stack traces would be ugly, though.

The tricky part is that a function doesn’t even need to name its arguments if it pattern-matches on them, for instance:

def foo([a | _], %{wat: b}) do
  ...
end

Replacing def with def_timed:

def_timed foo([a | _], %{wat: b}) do
  ...
end

could expand to something like:

def foo(arg1, arg2) do
  Timer.wrap_timed(
    &untimed_foo/2,
    [arg1, arg2],
    :foo
  )
end

def untimed_foo([a | _], %{wat: b}) do
  ...
end

untimed_foo would use the original args AST unaltered, while the code generated in foo only cares about length(args).

Supporting default args directly in def_timed would be a lot of extra hassle, but using a do-less def would let you avoid that:

def timed_thing_with_defaults(x, y \\ 1, z \\ 2)
def_timed timed_thing_with_defaults(x, y, z) do
  ...
end