How can a macro add variables to the generated context

msw10100

I’d like to define a module that uses a macros to simplify a user writing message handlers for a queue processing environment.

defmodule MyMessageHandlers do
  use MessageHandlers

  routed_message_handler("LoggerMessages", "StoreLogs") do
    IO.puts "Got message #{inspect message.type}"
  end
end

To implement routed_message_handler/3, I was thinking to use a macro, like:

defmodule MessageHandlers do
  defmacro routed_message_handler(message_class, message_name, do: expression) do
    quote do
      def handle("#{unquote(module)}#{unquote(message_name)}RoutedMessage", message) do
        unquote(expression)
      end
    end
  end
end

The macro would define a function with a signature built from the ‘message_class’ and the ‘message_name’, and would contain the code inside the ‘do’ block. But that won’t work because ‘message’ is only present in the generated code, not in the pre-macro-ized source, and so it can’t be found at compile time inside the ‘do’ block.

Is there a way to parameterize the ‘do’ block with ‘message’, so it’s available to the author of the actual message handling code?

Or is there a completely different way I can achieve this sort of thing?

This code is kind of trivialized just for this example, because there’s lots of other code that the generated message handler has to actually do. I’m trying to eliminate error-prone boilerplate from the message handling code.

4 comments

#macros

0 1333 4

2019-03-21 20:59:55 UTC

Showing Posts 1 to 4

Show Best Posts
Show All (oldest first)
Show All (newest first)

NobbZ

I once used var!/1 to implement something similar. Am on mobile though and can’t look up the code. Have to say though it was elixir 1.1 or 1.2.

Post #1

msw10100

Yep, var!/1 worked. My macro now looks like this:

  defmacro routed_message_handler2(module, message_name, expression) do
    quote do
      def handle("#{unquote(module)}#{unquote(message_name)}RoutedMessage", incoming_message) do
        var!(message) = incoming_message
        unquote(expression)
      end
    end
  end

And ‘message’ is now defined and available to be used in the context of the ‘do’ block.

Thanks!

Post #2

kip

ex_cldr Core Team

Maybe just me, but I think its a little "prettier"if the handle/2 generated function becomes a handle/3 like:

defmodule MessageHandlers do
  defmacro routed_message_handler(module, message_name, expression) do
    quote do
      def handle(unquote(module), unquote(message_name), var!(message)) do
        unquote(expression)
      end
    end
  end
end

Post #3

msw10100

That IS prettier, yeah.

Putting the var!(message) in the handler definition is definitely neater than declaring it in a separate expression. So now is looks like:

  defmacro routed_message_handler2(message_class, message_name, expression) do
    quote do
      def handle("#{unquote(message_class)}#{unquote(message_name)}RoutedMessage", var!(message)) do
        unquote(expression)
      end
    end
  end

I’m still likely to leave it as a handle/2 with a block, though, but only because the thing I have to match is a string inside the message header that contains the two message_class and the message_name and the literal “RoutedMessage”, and I’d rather not have to parse that before calling the handler.

Many thanks for the tip!

Post #4

— All posts loaded —