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.
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.
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
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.