What's the benefit of registering name using {:via, module, term} in GenServer.start_link/3?

Question

In GenServer.start_link/3 I can register a name locally using an atom for a process like this:

defmodule Worker do
  use GenServer

  def start_link do
    GenServer.start_link(__MODULE__, nil, name: :worker)
  end
end

Then I can start a supervisor to supervise this process:

defmodule Boss do
  use Supervisor

  def init(_) do
    children = [worker(Worker, [])]
    supervise(children, strategy: :one_for_one)
  end
end

Now I want to make the supervisor to supervise 3 Worker processes, so I need to give those 3 processes unique names, so that when supervisor restarts the process it will always use the same symbolic name.

I can simply use string interpolation for the unique Worker process name like this:

defmodule Worker do
  use GenServer

  def start_link(id) do
    GenServer.start_link(__MODULE__, nil, name: :"worker_#{id}")
  end
end

Then supervise 3 processes like this:

defmodule Boss do
  use Supervisor

  def init(_) do
    children = for id <- 1..3 do
      worker(Worker, [id], id: id)
    end
    supervise(children, strategy: :one_for_one)
  end
end

It works like expected.

In the doc for GenServer under "Name registration" section, it says you can use {:via, module, term} to register a name as well.

{:via, module, term} - the GenServer is registered with the given mechanism and name. The :via option expects a module that exports register_name/2, unregister_name/1, whereis_name/1, and send/2. One such example is the :global module which uses these functions for keeping the list of names of processes and their associated PIDs that are available globally for a network of Elixir nodes. Elixir also ships with a local, decentralized and scalable registry called Registry for locally storing names that are generated dynamically.

However, in order to use :via option you have to implement a module that exports register_name/2, unregister_name/1, whereis_name/1 and send/2, which seems pretty cumbersome comparing to simply use string interpolation technique as shown above.

So my question is:

1. What's the benefit of registering name using {:via, module, term} over simply using string interpolation?
2. Is there a pragmatic example of using :via option to register name?

Answer 1

tl;dr - :via is there to allow you to use non-standard process registration libraries. They must conform to an interface (much like implementing an interface in Java), and may provide extra functionality.

The main example is when you want to use a non-standard name registration library. Take for example the gproc library. It follows the interface requirements to use :via, so minimal intrusion is required into your application code. In addition, it provides several advantages over the standard name registration system:

1. Use any term as a process alias
2. Register a process under several aliases
3. Non-unique properties can be registered simultaneously by many processes; query level comprehension (QLC) and match specification interface for efficient queries on the dictionary
4. Await registration, let's you wait until a process registers itself
5. Atomically give away registered names and properties to another process
6. Counters, and aggregated counters, which automatically maintain the total of all counters with a given name
7. Global registry, with all the above functions applied to a network of nodes

Elixir's Registry module is another example of one which requires a via tuple.