Call callback-function inside Behaviour-Module

kai_feldhoff

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

4 comments

#behaviours #callbacks

0 314 4

2024-11-13 19:30:21 UTC

Showing Posts 1 to 4

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

LostKobrakai

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.

Post #1

dimitarvp

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.

Post #2

kai_feldhoff

Thank you two for your quick feedback!

This convinces me to keep this track.

Post #3

al2o3cr

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.

Post #4

— All posts loaded —