A better Module interaction pattern?

CharlesO

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.

14 comments

#behaviours #learning-elixir

0 680 14

2024-10-14 14:49:42 UTC

Showing Posts 1 to 10

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

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.

Post #1

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.

Post #2

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.

Post #3

CharlesO

I’m trying to understand you point sir.

Say I have more functions in handler module, and i want to ensure that every customer module implements all the functions correctly, then just like GenServer we coukd use @behavior correct?

Post #4

CharlesO

In my case i have the same app deployed to different customers.

Each customer has specific processing they need.

I implement a module per customer, then in config, i have a customer_module_name setting.

In this module, i do the customer specific processing.

The main app, looks for module name, then calls a function: process_data, which every customer module is expected to have implemented.

Post #5

dimitarvp

Sounds like what I did but with multiple dispatchers (one per customer).

Why are you not satisfied with that solution?

Post #6

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

Post #7

al2o3cr

The major benefit is compile-time checking:

if CustomerA says @behaviour Handler but 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.

Post #8

CharlesO

Please can you point to a simple reference implementation?
I’ve not written this type of behavior module before.
I understand it requires macros, yes?

Post #9

thomas642daniel

CharlesO:

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?