Fallback to nearest prior imported library module and not necessarily Kernel when overriding an operator?

How about Kernel.defoverridable/1?

Never applied it in a case like this. This is not an “inheritance” case. You think it will work?

Nope, I can’t get it to work. Besides, even if it did work, it would require other libraries to define it too.

It would be easier if you would give something from you like an example Elixir script or at least tell us what error you have.

I can’t get it to work.

does not tell us anything.

Ok. For starts, here’s the sketch of the original that I explained above that works, but imports all functions and macros from a prior library (the operator is - but it’s still the same point).

defmodule Helpers do
  def prev_import( caller_env, fun_name, arity, to_reject) do
    Macro.Env.lookup_import( caller_env, { fun_name, arity})
    |> Enum.reject( & &1 in to_reject)
    |> List.last()
    |> then( & &1 && elem( &1, 1))
  end
end

defmodule OtherLibrary do
  defmacro __using__( _) do
    prev_import = Helpers.prev_import( __CALLER__, :-, 1, macro: OtherLibrary)

    quote do
      import unquote( prev_import), except: [ -: 1]
      import OtherLibrary, only: [ -: 1]
    end
  end

  defmacro -value do
    IO.inspect( value, label: "OtherLibrary")
    OtherLibrary.doit( value, __CALLER__)
  end

  def doit( { :&, _, _}, _caller_env) do
    IO.puts( "OtherLibrary caught it!")
  end

  def doit( other, _caller_env) do
    quote do
      -unquote( other)
    end
  end
end

defmodule MyLibrary do
  defmacro __using__( _) do
    prev_import = Helpers.prev_import( __CALLER__, :-, 1, macro: MyLibrary)

    if prev_import && __CALLER__.module do
      Module.put_attribute( __CALLER__.module, :prev_import, prev_import)
    end

    quote do
      import unquote( prev_import), except: [ -: 1] # note: this is a problem for it imports all else even if unwanted
      import MyLibrary, only: [ -: 1]
    end
  end

  defmacro -value do
    IO.inspect( value, label: "MyLibrary")
    MyLibrary.doit( value, Module.get_attribute( __CALLER__.module, :prev_import))
  end

  def doit( { :%{}, _, _}, _) do
    IO.puts( "MyLibrary caught it!")
  end

  def doit( other, prev_import) do
    IO.puts( "MyLibrary passing it on to prev..")
    IO.inspect( prev_import)

    if prev_import do
      quote do
        unquote( prev_import).-( unquote( other))
      end
    else
      quote do
        -unquote( other)
      end
    end
  end
end

defmodule LibraryUser do
  use OtherLibrary
  use MyLibrary

  def run_map() do
    -%{ a: 1}
  end

  def run_capture() do
    -&bla
  end

  def run_other() do
    -2
  end
end

• edit: removed obsolete comments from code

Regardless of the defoverridable/1, if I remove the lines with import unquote( prev_import) .. it will complain about ambiguous call of the - operator. If I don’t remove the lines, I am importing all the functions and macros.

I mean as a general rule, I would simply not try to do this at the module level. If a library wants to override an operator that should be lexically scoped inside one function at a time.

There is no good solution for this. Look that if you do import … except … then what happens with all previous imports?

For example:

defmodule Example do
  import Kernel. except: [+: 2]
  use OtherLibrary
  use MyLibrary

  # …
end

Firstly I would go for: Defining custom operators. and then I would register an (accumulate?) attribute :prev_import and within use Helper I would get said attribute and define a custom function/macro depending on value of such attribute.

Alternative both libraries could put an attribute and add @before_compile which would work as same as use Helper.

Yes, and there’s also another solution and that is not to stop at just taking the prev_import but then also (while still in compile time) take all of the module’s macros and functions and exclude them all unless already imported, but it’s already getting cumbersome.

My point being:

1. There’s a scarcity of custom operators, unary in particular.
2. It wouldn’t hurt if import had an additional option (say :not) to un-import some but not import all other functions/macros.

Just sayin’

Your observation is valid if the library is a very specific one. But if you’re developing something of a very generic purpose that can be applied all over your code base, then evading this problem will hardly do it. Still, even if done on a function by function basis, I am simply reluctant of importing all of third party module’s functions/macros just because I need to exclude one.