Nicest way to emulate function decorators?

I’d probably just make something that the user could use just via:

defmodule SomeUserModule do
  use Instrumented,
    funs [
      (:hello, 0)
      ]

  def hello, do: "world"

  # .. lots of more functions
end

In your use you can hook all the functions that are listed by the tuple of the funName and funArity and use a macro to hook the def’s and instrument the ones that match the list. That seems like the easiest way to hook that. Could do an :all or so for the funs to say to do everything

Or you could do something like this if you want to mark ‘at’ the function site:

defmodule SomeUserModule do
  use Instrumented

  @instrumented
  def hello, do: "world"

  # .. lots of more functions
end

Where that would basically do the same thing but you’d walk the ast looking for that attribute than an immediately following function declaration or so.

It would be entirely possible for someone to make a generic ‘function decorator’ macro module that works like that, could do things like @decorate SomeModule.functionWrapper or so before the functions. Unsure if anyone’s made one yet, but eh?

Yes this latest idea was how I envisioned implementing it, walking the AST looking for module attributes next to a def. However, I dont know where I should hook in to, @before_compile does not allow you to alter the AST, iirc.. and __using__ only allows you to add code to the end of the module.

What about the @on_definition hook?

You can always hook def itself within the module with a macro and have it either call to the normal def or do special things based on information too (that would work well with the first style especially), or at least using it for the second style and renaming the function (adding a NONINSTRUMENTED_ or so to everything) then setting up trampolines with instrumenting or not at the end based on the annotations.

Yes, overriding def with a macro seems possible however I still don’t know how to get the @ attributes preceding the def, because I’m not sure there is a way to get the entire AST tree in some kind of hook and alter it.

I’m starting to lean to your first suggestion:

use InstrumentedDefs, foo: 2, bar: 3

Use a generic callback for def, when it gets called, check if @instrumented is set as a module-attribute, if so, do your stuff and unset it. If it is not set just do nothing.

There are some handy functions in the Module-module to work with module attributes ((get|put|delete|register)_attribute/*)

Thanks. But I guess I also need to check its position in the AST - basically misuse module attributes to check whether an attribute occurs just before a def.

Maybe if I put the decorators inside the function as the first thing, I can get away with just overriding def:

def some_function(bar) do
  @instrumented
  # ... do stuff
end

Why do you need it to be the very last thing before the function or the very first in it? If you are too strict, it will be impossible to compose such annotations.

Also, why should it matter if one writes variant A or B?

A:

@instrumented
@doc "documented!"
def foo(bar), do: bar

B:

@doc "documented!"
@instrumented
def foo(bar), do: bar

Of course you can exchange @doc with @spec or any other function level attribute or combinations thereof.

PS: AFAIK you cant do just an empty attribute you need to assign something to it.

It doesnt need to be strictly the last attribute before the def but the attribute should be scoped to the function somehow, e.g. some defs need instrumentation, others dont:

def foo(bar) do
  # not instrumented

@instrumented
def i_am_instrumented(bar) do
  # ...

def foo2(bar) do
  # not instrumented, again

I know about attribute definitions needing definition but inside the __using__ the attribute can get defined.

You have missed some of my points.

When you define @instrumented in the using, it will get replaced by that value in the sourcecode on every occurence, this can make your sourcecode invalid.

My proposal was to explicitely set it before functions, maybe specifying some extra stuff (similar to ExUnits @tags). And unset it in the callback.

Ah! That makes sense suddenly.
So @instrumented “blablah” just before a def (which is an overridden macro); and then the macro does its AST magic, and unsets the attribute. Neat! I’ll try that.