Alex Martelli wrote:
[SNIP a bunch or erudite stuff.]
>
>
> Here is a simple reference implementation of adaptation under all of
> these simplifying assumptions:
>
> _global_registry = {}
>
> def register_adapter(T, P, A, registry=_global_registry):
> registry[T, P] = A
>
> def adapt(t, P, registry=_global_registry):
> return registry[type(t), P]
This is more like it. I suspect that last line has a typo: I think it
needs a "(t)" appended to it, but that's minor. It's great to see
someone who knows something about adaption put forward a reference
implementation that's grockable.
Remarkably, it looks a lot like my implementation that I posted in
parallel with this. Let's compare:
> # adapters.py
> registry = {}
> def register(adapter, resultdescr, *targetdescrs):
> for x in targetdescrs:
> registry[(resultdescr, x)] = adapter
> def find(resultdescr, targetdescr):
> return registry[(resultdescr, targetdescr)] # fixed type here
There are some superficial differences, but the only substantial
difference is that I chose to use 'find' to get an adapter, rather than
to actually do the adaption using adapt. This was a conscious choice,
driven by my desire to avoid tying targetdescr to concrete types. My
proposal is dumber, and thus more flexible.
Let me give an example where this would matter based, more or less, on
real code. I load pairs of numpy arrays from a file. These pairs
represent imaginary numbers but they may be in several different
formats: real-imag, mag-angle or db-angle. The format is specified in
the file and the arrays gets tagged with this format when they are loaded.
Now lets suppose I want to use adaption to handle this. Trying to use
concrete types is a mess here. However, in the find proposal, I can
simply punt and use strings:
def register(z_from_ri, "complex_array", ('real_array', 'imag_array'))
def register(z_from_ma, "complex_array", ('mag_array', 'angle_array'))
def register(z_from_dba, "complex_array", ('db_array', 'angle_array'))
#...
def f(a1, a2):
adapter = adaption.fine("complex_array, (a1.descr, a2.descr))
z = adapter(a1, a2)
It's also very easy to register a new type if I need to do so. Suppose
that they add mag, radians. No problem:
def register(z_from_mrad, "complex_array", ('db_array', 'radian_array'))
I've completely punted on any attempt at avoiding collisions. All of
these names would want to be prefixed, or some other method found, to
avoid collisions, as you (Alex) already mentioned.
That's my take, FWIW, which is probably not much considering I've never
tried to use adaption, or at least not that I've noticed, in real life.
[SNIP]
Regards,
-tim
_______________________________________________
Python-3000 mailing list
Python-3000@python.org
http://mail.python.org/mailman/listinfo/python-3000
Unsubscribe:
http://mail.python.org/mailman/options/python-3000/archive%40mail-archive.com
