Possible PEP: smart modules

[David Abrahams]

In my work on Boost.Python (www.boost.org) a colleague suggested the
implementation of "cross-module overloading". Boost.Python allows function
overloading within a module or class as a way of reflecting the structure of
the C++ program being wrapped. That means, for example, that in:

  import MyExtensionModule
  MyExtensionModule.f("hello there")
  MyExtensionModule.f(42)
  MyExtensionModule.f("this", "way", "please")

The invocations of f() might all call different functions.

How would this work "cross-module"?

    from MyExtension1 import f
    from MyExtension2 import f

    f(42)      # calls MyExtension1.f
    f("hello") # calls MyExtension2.f

We can't do this right now because the second import will unconditionally
overwrite the current definition of f. I propose that we give the modules
some control over what happens when their names are imported into an
existing namespace. If that were possible, the second import might notice
that there was already a callable object named "f" and replace the name
being imported with some collection of functions which implemented the
overloading (that's how the single-module overloading mechanism works now).

So, as a straw man, let me propose a syntax. If a module defines an
__import__ function as follows:

   __import__(source-module, source-name, target-module, target-name)

it will be called for each name being imported from that module into
another. In other words, source-module will always be the module in which
the __import__ function is defined, and target-module will be the module
into which the names are being imported. source-name is distinguished from
target-name in order to support "from Module import A as B".

--
===================================================
  David Abrahams, C++ library designer for hire
 resume: http://users.rcn.com/abrahams/resume.html

        C++ Booster (http://www.boost.org)
          email: david.abrahams at rcn.com
===================================================