Seconded, I use the do_* private functions notations myself. Mostly because I have no better idea.

It seems that do_* has become a convention
By the way, I follow this convention, too.

This is one of my favorite patterns, the _guarded suffix. You do all your guard checks in your public function, and you delegate to a private one and call it recursively if needed, without checking for a guard again and increasing performance.

This is the current implementation for Keyword.update/4

  @spec update(t, key, default :: value, (existing_value :: value -> new_value :: value)) :: t
  def update(keywords, key, default, fun)
      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
    update_guarded(keywords, key, default, fun)
  end

  defp update_guarded([{key, value} | keywords], key, _default, fun) do
    [{key, fun.(value)} | delete(keywords, key)]
  end

  defp update_guarded([{_, _} = pair | keywords], key, default, fun) do
    [pair | update_guarded(keywords, key, default, fun)]
  end

  defp update_guarded([], key, default, _fun) do
    [{key, default}]
  end

There is no way to detect if You call list_company_users/3 without filter, and list_company_users/2

You might add guard clauses…

# Use when is_binary if You use binary id.
def list_company_users(%User{} = current_user, company_id, filters \\ %{}) when is_integer(company_id) do
    # some logic
end

defp list_company_users(company_id, filters) when is_map(filters) do 
  # some logic
end

I also prefer do_* for private functions…

You might also check how to use function’s signature

Thank you for all the replies. It does seem the Elixir community has a convention of doing do_* for private functions. I’m going to try it out and see how it feels.

Thank you everyone for the replies!