How to provide an interface to an existing Erlang behaviour

I’m trying to provide/extend an existing Erlang behaviour in a library to use it with Elixir.
Said behaviour is called :riak_core_vnode, it has some setup quirks to make it to work with Elixir, so I wanted to make a sort of a wrapper behaviour, my idea is to create a module that implements said behaviour and defines a new behaviour (let’s call it :elixir_vnode for clarity’s sake). Then, a user of this behaviour would only have to implement it and the only thing my module should be doing is call the user’s defined function.
A more concrete example would be something like this:

defmodule MyWrapper do
 @behaviour :quirky_erlang_behaviour
 @callback not_weird_function(params :: any) :: :ok
 def weird_function(params) do

First thing that comes to mind is to use a config option to determine which module is UserDefinedModule, something like:

config :my_lib, user_provided: UserDefinedModule

And then, weird_function would be something like:

def weird_function(params) do
  user_module = Application.get_env(:my_lib, :user_provided)

Is there a cleaner, or more simple, way to do this?

A behaviour is ultimately just a list of callback specs, that you tell the compiler to enforce with @behaviour so that you can pass the module along to functions that expect those callbacks (for instance, passing it to :riak_core_vnode.start_link/3)

You could look to GenServer for inspiration - it defines a __using__ that applies the @behaviour and includes some default implementations:

But notice what it doesn’t do: put @behaviour :gen_server anywhere. The callbacks have the same specs, but they are incorporated by copying instead of by reference. That may be a special case related to GenServer, though, since changing the callback functions in :gen_server would break… many things.

If you’re aiming to implement a different set of callbacks, you could make a __using__ that adds @behaviour YourWrapper and @behaviour :riak_core_vnode and supplies implementations for all the riak_core_vnode functions. Then calling code would look like:

defmodule AnElixirVnode do
  use YourWrapper

  @impl true
  def some_callback(arg, arg, arg) do

I like the __using__ solution, I’ll look into it, thanks!