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@rcn.com
===================================================