CharlesO
A better Module interaction pattern?
I’m looking to improve this pattern.
It is a pattern I use in a lot of my projects.
defmodule Handler do
def handle_request(data) do
response = apply(@some_module_from_config, :parse, [data])
# do_something_with_response(response)
...
end
end
I then have customer specific implementations of :parse in separate modules, for example
defmodule CustomerA do
def parse(data) do
# specific parsing of this data for Customer-A
end
end
defmodule CustomerB do
def parse(data) do
# specific parsing of this data for Customer-B
end
end
This works, but can it be improved?
Is there a benefit for example to have a @behaviour in Handler which defines :parse and other functions
Then each Customer module no implements use Handler
Please are their better patterns for doing this?
Thanks.
Marked As Solved
D4no0
Nope, all you need is something like this:
defmodule ParseBehavior do
# Obviously replace any with your data types
@callback parse(data :: any) :: any
end
defmodule CustomerA do
@behaviour ParseBehavior
end
If you don’t implement the specified callbacks you will get a compilation warning.
You can also have the variant with the default implementation:
defmodule ParseBehavior do
@callback parse(data :: any) :: any
defmacro __using__(_opts) do
quote do
@behaviour ParseBehavior
def parse(data) do
# This will be the default implementation if not overriden
end
defoverridable parse: 1
end
end
end
defmodule CustomerA do
use ParseBehavior
# This definition will override the default definition
def parse(data) do
end
end
I wouldn’t recommend using the variant with default implementation unless that is strictly required, as it makes the code harder to read.
Also Liked
al2o3cr
The major benefit is compile-time checking:
- if
CustomerAsays@behaviour Handlerbut doesn’t supply callbacks with the correct arities, the compiler will complain - (sometimes) Dialyzer will be able to prove that a function’s implementation fails to match the behaviour’s spec
As a side bonus, libraries like mox can use that same behaviour for their definitions.
Eiji
No need to use apply as it’s much more useful if you have function name stored in variable.
` response = @some_module_from_config.parse(data)`
Not only it would not give you any benefit, but it would also be wrongly used.
In Handler module you have to define callbacks and / or macrocallbacks. You use @behaviour attribute in CustomerA and CustomerB modules. In this tiny example it’s not important at all, but in general you use this to make sure that all callbacks are implemented as Elixir gives compilation warning otherwise.
egze
I also recommend watching the keynote from José https://www.youtube.com/watch?v=agkXUp0hCW8
He goes into the topic what to use when.
dimitarvp
How does your code branch on input data and decides which module to use?
I just recently had to do this and since I did not have a lot of modules and not too many input shapes I just made a router / dispatcher module that basically pattern-matches on the input and calls different module + function combo i.e.
module = Commands.detect_by_args(input)
module.perform(args)
Where Commands.detect_by_args/1 simply uses several pattern-matching function heads.
Eiji
Behaviours are well documented, so it would be easiest to check it out. For example here is a quote I was referring to:
If a module adopting a given behaviour doesn’t implement one of the callbacks required by that behaviour, a compile-time warning will be generated.
Source: Behaviours | Typespec reference @ Elixir’s documentation
Popular in Questions
Other popular topics
Latest on Elixir Forum
Sponsor Spotlight
Build Elixir applications with speed and confidence.
Categories:
Sub Categories:
Forums
Our Sponsors
Build Elixir applications with speed and confidence.
Supporting innovation across the BEAM ecosystem.
We build reliable cloud platforms for business-critical systems.
Catch errors, track performance, monitor hosts and more.
Practical resources that improve the lives of professional developers.
Producing high quality Elixir screencasts since 2017.
The deployment platform built for Elixir: PaaS ease, VPS control.
Courses that'll move you from confusion to "Aha, now I get it!"