How to properly implement dynamic dispatch?

Hi,

I believe there is no magic in dynamic dispatch. What might be missing in the example is how to use parse!

As I understand it you use parse the following way (assuming you have JSONParser defined):

Parser.parse!(JSONParser, "some string")

I hope that helps,

Pawel

Oh… I thought if there is a module JSONParser that has a line @behavior Parser then I could just call JSONParser.parse!("some string") and the dispatch would happen correctly. Isn’t that how we use GenServer and then call the using class’s start_link instead of GenServer’s start_link, right?

How do I write a function that uses the callbacks in the behavior definition then?
Eg handle_call is a GenServer function that has a specific signature. How do I access the implementation’s functions in that case? A plain inputs or handle_data doesn’t work, and I can’t expect GenServer to call handle_data with the implementation module. does __MODULE__ correspond to the currently active module? Is there something like self in python?

I think you are mixing up concepts. Behaviours is just a way to define callbacks that must be implemented, and some can be optional. use can be used in behaviours and protocols to define generic definitions of these callbacks, but nothing stops you from using use out of these situations.
As @pickme467 there is no magic in behaviours, the magic happens with use unless you read the source code you never know what’s happening behind the scenes.

You could achieve JSONParser.parse!("some string"), you would have to define it in your Parser.__using__/1 macro and call use Parser

Ok…

so if I have a behavior like:

defmodule X 
@callback one(any) :: integer 
@callback two(any) :: integer
end 

How do I achieve a pattern like “I want to write a function that an implementor of this behavior will get by default”? I was trying:

defmodule X 
@callback one(any) :: integer
@callback two(any) :: integer
def three(o, t) do one(o) + two(t) end
end

This is not right because behaviors don’t work like that… I have to use the using macro:

defmodule X 
@callback one(any) :: integer
@callback two(any) :: integer
defmacro __using__ do
  def three(o, t) do one(o) + two(t) end
end
end

Then I would use X instead of @behavior X so that I get the extra code that I want.
Is that correct? Is there a better way of doing this?

You are about right.
This is the real implementation.

defmodule X do
  @callback one(any) :: integer
  @callback two(any) :: integer

  defmacro __using__(_options) do
    quote do
      @behaviour X

      def three(o, t) do
        one(o) + two(t)
      end
    end
  end
end

defmodule XImpl do
  use X

  @impl X
  def one(string) when is_binary(string),
    do: String.length(string)

  @impl X
  def two(string) when is_binary(string),
    do: String.length(string)
end

iex(1)> XImpl.three("abcd", "x")
5

If you just want to use use X, you need to add @behaviour X inside your using macro

Additionally in X you can define @callback three(any, any) :: integer(), and inside __using__ set defoverridable: three: 2

^ What does adding that extra callback do? IIUC, it’s making three part of the contract of the behavior (so any code that relies on an X can expect a three even if the implementation doesn’t use X?

defmodule X do
  @callback one(any) :: integer
  @callback two(any) :: integer
  @callback three(integer, integer) :: integer

  defmacro __using__(_options) do
    quote do
      @behaviour X
      defoverridable: three: 2
      def three(o, t) do
        one(o) + two(t)
      end
    end
  end
end

Is that right?

And say I want X to use a behavior as well, like GenServer. So all implementers of X should transitively use GenServer. Does that go under __using__ or in the main module definition?

so is it

defmodule X 
use GenServer
@callback ... 
  
defmacro __using__ do 
...
end
end

or

defmodule X 
@callback ... 

defmacro __using__ do quote do 
use GenServer
end 
end 
end

Yes. that’ s correct.

Regarding your second question, what I can recommend you is do not use use X to start with, see where use GenServer will go, and if it makes sense where you will have to define the callbacks. Then try to abstract things into X.__using__/1 and see what will make the best use of use X. remember use just inserts code. You can pretty much copy and paste and port the quoted parts. You will figure it out.