In my current project I have a rather complex data-tranfsformation. Additionally there are several flavors fo ths trqansormation that share a lot of behaviour.
Is therea any other may to call a callback-function inside a bahaviour apart from passing the module-name of the callback-module like this?
defmodule MyBehaviour do
@callback specific_handling(data :: term) :: term
@callback very_specific_handling(data :: term) :: term
defmacro __using__(_opts) do
quote do
@behaviour MyBehaviour
alias MyBehaviour
def initiate_processing(data) do
MyBehaviour.process_data(data, __MODULE__)
end
end
end
def process_data(data, callback_module) do
data
|> do_stuff_with_data(callback_module)
# and other calls to behaviour-functions
|> callback_module.specific_handling()
end
defp do_stuff_with_data(data, callback_module) do
data
# and other calls to behaviour-functions
|> do_specific_stuff(callback_module)
end
defp do_specific_stuff(data, callback_module) do
data
# and other calls to behaviour-functions
|> callback_module.very_specific_handling()
end
end
defmodule DataHandler11 do
use MyBehaviour
def specific_handling(data) do
# do specific stuff with data
data
end
def very_specific_handling(data) do
# do specific stuff with data
data
end
end
defmodule DataHandler12 do
use MyBehaviour
def specific_handling(data) do
# do specific stuff with data
data
end
def very_specific_handling(data) do
# do specific stuff with data
data
end
end
data = nil
handler = 1
case handler do
1 -> DataHandler11.initiate_processing(data)
2 -> DataHandler12.initiate_processing(data)
end
That’s exactly how callback modules are meant to be used. Provide them to generalized code and let that generalized code call into function on the callback module where needed.
I would give you a thumbs up during code review on a PR like this – it’s all good.
If you are worried about this approach then the only other practice that’s more “micro” would be to only pass function references – but then you would be losing the compiler warnings if a contract is violated i.e. if the function has the same arity but accepts different kinds of arguments.
So IMO callback modules are the right solution here.
Another option would be to generate all the required code into the module that says use. This replaces threading callback_module everywhere by local calls:
defmodule MyBehaviour do
@callback specific_handling(data :: term) :: term
@callback very_specific_handling(data :: term) :: term
defmacro __using__(_opts) do
quote do
@behaviour MyBehaviour
alias MyBehaviour
def initiate_processing(data) do
data
|> do_stuff_with_data()
# and other calls to behaviour-functions
|> specific_handling()
end
defp do_stuff_with_data(data) do
data
# and other calls to behaviour-functions
|> do_specific_stuff()
end
defp do_specific_stuff(data) do
data
# and other calls to behaviour-functions
|> very_specific_handling()
end
end
end
end
defmodule DataHandler11 do
use MyBehaviour
def specific_handling(data) do
# do specific stuff with data
data
end
def very_specific_handling(data) do
# do specific stuff with data
data
end
end
defmodule DataHandler12 do
use MyBehaviour
def specific_handling(data) do
# do specific stuff with data
data
end
def very_specific_handling(data) do
# do specific stuff with data
data
end
end
data = nil
handler = 1
case handler do
1 -> DataHandler11.initiate_processing(data)
2 -> DataHandler12.initiate_processing(data)
end
This has a cost: the code output by __using__ is compiled over again for every module that calls it, versus only being compiled once when MyBehaviour is compiled.
