alias and import serve complete different purposes than defdelegate. defdelegate is about extending your public API by delegating to something else, that’s why it has different requirements.

I really dislike from module import function as new_name seen in Python and in other languages because you are introducing a name in that project that can’t be found anywhere else. If you rename something to prefix_foo_bar, that name exists only in that file, and trying to look for it in the documentation, Google, or anywhere else will most likely fail. If you really want to rename something, it is better to be explicit at it and define a private function you use locally. Or, as others have said, rely on aliases to do the disambiguation.

We can’t evaluate language features in a vacuum. In Python, I don’t think you can meta-program the construct above, so it is always explicit. In Elixir, however, that could be hidden inside a use, and that would be a recipe for disaster.

There are other ways to work around import limitations, defdelegate is not one of them.

The concrete realization of e in comments above depends on your needs, thats because we are asking you about your whole problem. I think, you don’t need Macro.escape at all. For example to match on map keys solution may looks like this:

defmodule Test do
  defmacrop e(kv) do
    quote do
      %{unquote_splicing(kv)}
    end
  end

  def me(e(a: 10)), do: :a_key_10
  def me(e(a: 20)), do: :a_key_20
  def me(e(b: _)),  do: :b_key
end

then in iex:

iex(3)> Test.me(%{a: 10})
:a_key_10
iex(4)> Test.me(%{a: 20})
:a_key_20
iex(5)> Test.me(%{b: :any})
:b_key

How would renaming functions be clearer than using the OtherModule.function if function is also defined in the local module? If you rename functions on a per module basis I’d rather expect that to become a hot mess very soon. I’d argue that if you have conflicting imports opting for require Module or require MyApp.Super.Long.Module, as: Module is the better solution (or alias instead of require if it’s not about macros).

You can’t define a shortcut for that. This is not related to import, alias or defdelegate. unquote makes sense only inside a quoted expression because it is a way to tell quote that it should not touch that particular piece of code.

To make a comparison, what you are asking is to move the #{inspect(foo)} from "a string: #{inspect(foo)}" to a separate function. But #{...} only makes sense inside a string.

EDIT: What you can do, if your macros are verbose, is to escape before the quote, instead of defining all of the code inline. Instead of:

quote do
  ...unquote(Macro.escape(x))...
end

You can do:

x = Macro.escape(x)
quote do
  ...unquote(x)...
end

But keep in mind quote and unquote in Elixir are verbose on purpose (especially compared to Lisps which often have one or two special characters for those) because we want you to be careful with your macro, quoting and unquoting usage.