I’m struggling to understand behaviours and dynamic dispatch. The example in the getting started with elixir page doesn’t make any sense to me:
defmodule Parser do
@callback parse(String.t) :: {:ok, term} | {:error, String.t}
@callback extensions() :: [String.t]
def parse!(implementation, contents) do
case implementation.parse(contents) do
{:ok, data} -> data
{:error, error} -> raise ArgumentError, "parsing error: #{error}"
end
end
end
Where does the implementation come from?
I tried using this myself when writing a module and I am doing something wrong, just not clear what. I don’t understand how to use the implementation’s functions when writing the handle_call method:
defmodule Program do
use GenServer
@callback inputs() :: [atom]
@callback init(term) :: any
@callback handle_data(any, map, map) :: term
@callback emit(term) :: map
@impl GenServer
def init(arg) do
## How do I use the implementation's inputs function? there's no implementation passed in here
__MODULE__.inputs
|> Enum.each(fn x -> Phoenix.PubSub.subscribe :inputs, x end)
{:ok, {%{}, __MODULE__.init(arg)}}
end
@impl true
def handle_call(%OSC.Message{address: address, arguments: arguments}, _, {inputs, state}) do
data = get_latest_reading(address, arguments)
newinputs = %{inputs | address => data}
# Same question in this area
if map_size(newinputs) === length __MODULE__.inputs do
newstate = __MODULE__.handle_data(state, inputs, newinputs)
__MODULE__.emit(newstate)
|> Enum.map(fn {k, v} -> Phoenix.PubSub.broadcast(:outputs, k, v) end)
{:noreply, {newinputs, newstate}}
else
{:noreply, {newinputs, state}}
end
end
def get_latest_reading(address, arguments) do
receive do
%OSC.Message{address: ^address, arguments: args} ->
get_latest_reading(address, args)
after 0 -> arguments
end
end
end
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
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
^ 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
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.
