Python and generic programming

[Roman Suzi]

Hi,

I wonder, does Python support generic programming paradigm, and to what extent
(I guess, it doesn't do it in full)? And (or) does it move in that direction?
Will we ever see

concept WellAlright:
...

constructs in Python?
Isn't it right time to reserve "concept" as a keyword ;-)
Sincerely yours, Roman Suzi
--
rn*@onego.ru =\= My AI powered by GNU/Linux RedHat 7.3

[Jive]

I hate to break it to you Terry, but Issac did understand the question. The
example he gave was perhaps a little fanciful, but it was on the money.
That is exactly the kind of thing I was asking about.

More typical examples of specialization may be found in the Standard
Template Library, and in the Boost Graph Library.

When you define a function in Python, you are (in effect) defining many
functions, just as Issac says. What the byte codes eventually do depends on
type information that is acted on at runtime. C++ has a mechanism
(templates) for acting on the type information similarly, but at compile
time. However, a modern C++ compiler can do something beyond that. It can
recognize special cases (which the programmer must code for) and use a
different functional form (template) for the special case than for the
generic case. Both STL and BGL use the mechanism extensively.

jdadson at yahoo dott com

"Terry Reedy" <tj*****@udel.e du> wrote in message
news:ma******** *************** *************** @python.org...

"Isaac To" <ik****@netscap e.net> wrote in message
news:87******** ****@sinken.loc al.csis.hku.hk. ..

"Terry" == Terry Reedy <tj*****@udel.e du> writes:

Terry> Specialization goes in special methods -- the ones named
Terry> __xxx__ -- of which there are now 50-100.

No, you don't quite understand what the OP is asking for.
No, YOU are the one who does not understand, because you apparently did

not do me the courtesy of reading my entire post, in which I quoted the
question I answered. Here again is the OP's question about *type*
specialization *in Python*:
If you have, for example, several data-types for matrices, how do you
write code that will automatically find the right routine for quickly
multiplying a vector by a diagonal matrix represented as a vector, and
automatically call the right code for multiplying by a sparse matrix
represented by some sparse coding, etc?

The has NOTHING to do with writing base cases in recursive C++ template
metaprogramming (which, ironically, uses the compiler as an interpreter).

Although there may be other answers now and in the future, the answer I
gave is the straightforward standard answer for Python today.

Terry J. Reedy

[Isaac To]

>>>>> "Terry" == Terry Reedy <tj*****@udel.e du> writes:

No, you don't quite understand what the OP is asking for.

Terry> you apparently did not do me the courtesy of reading my
Terry> entire post, in which I quoted the question I answered.

I admit that I didn't read your mail very carefully when I write my
response. I did that immediately afterwards, and my post didn't make
sense even to myself. So I cancel that post a minute after making it,
although apparently my cancel posting didn't go as far as my response.

Terry> The has NOTHING to do with writing base cases in recursive
Terry> C++ template metaprogramming (which, ironically, uses the
Terry> compiler as an interpreter).

I see no problem using the compiler as an interpreter. Indeed, I
think C++ should make it more explicit and allow one to do things in
compile time as easily as one can do at run-time (e.g., why only
support integers, and why one have to do recursions instead of
loops?). But this is a Python group, not a C++ group, so such things
are off-topic here.

Terry> Although there may be other answers now and in the future,
Terry> the answer I gave is the straightforward standard answer
Terry> for Python today.

On the other hand, I didn't agree with this. Your answer basically
said "define a member function called __mul__ for each class you
have", which I don't think is what the OP asked for. First, nothing
in the original post said he wants the function to be used with
operator syntax, so __mul__ or other __xxx__ member functions should
be considered off-topic. Second, the OP asked for "specialization ",
and, as an example, asked for a way to cause the system "automatica lly
finds the right routine for [one type], and automatically call the
right code for [another type]". Your answer involves defining a
method for each type one creates, which (1) is not automatic, and (2)
requires one to modify the class, which is not what is expected by a
C++ programmer who are used to template functions and specialization.

Template specialization is a dispatch mechanism that is external to a
class. You probably mean "such mechanism is missing in Python". I'm
not quite sure that is correct, though.

Regards,
Isaac.

[Carl Banks]

"Jive" <so*****@micros oft.com> wrote in message news:<su******* *************** @news.easynews. com>...

When you define a function in Python, you are (in effect) defining many
functions, just as Issac says. What the byte codes eventually do depends on
type information that is acted on at runtime. C++ has a mechanism
(templates) for acting on the type information similarly, but at compile
time. However, a modern C++ compiler can do something beyond that. It can
recognize special cases (which the programmer must code for) and use a
different functional form (template) for the special case than for the
generic case. Both STL and BGL use the mechanism extensively.

This doesn't look too hard. Untested, cause I don't have Python 2.4
yet:

def generic(genfunc ):
speclist = []
def wrapf(arg):
for (specfunc,typ) in speclist:
if isinstance(arg, typ):
return specfunc(arg)
return genfunc(arg)
wrapf.speclist = speclist
wrapf.func_name = genfunc.func_na me # isn't this ok in 2.4?
return wrapf

def specializes(gen f,typ):
def spd(specf):
genf.speclist.a ppend((specf,ty p))
return specf
return spd

# so my European friends don't get too upset
specialises = specializes

Then:

@generic
def some_function(a rg):
print "generic"

@specializes(so me_fuction,int)
def some_int_specif ic_function(arg ):
print "int-specific"

Whence calling some_function(' abc') prints "generic", and calling
some_function(1 23) prints "int-specific".

Obviously this example could use lots of improvement. It only works
for functions of one argument, and it could probably do better than a
linear search through the type-dispatch list. But it does show how it
can be done.

A couple things: I personally have a distaste for specializations ,
because of the easy possibily that what is supposed to be an
optimized, but equivalent, version of the generic function does
something different (intentionaly or not). IMO, that's much too stiff
a price for a premature optimization. They should rarely be used
outside the final stages of development. Or if you WANT the
specialization to behave differently, you ought to be using regular
old polymorphism.

Having said that, if you're going to use specializations , then the way
I did it above, by explicitly defining functions as generic and
specialized, is a much better way to do it than in C++ IMO. At least
then you get advance warning of any surprises. "Explicit is better
than implicit", 'n at. By not supporting implicit specializations , I
think Python's doing a good job.
--
CARL BANKS

[Richie Hindle]

[Isaac]

[...] my post didn't make
sense even to myself. So I cancel that post a minute after making it,
although apparently my cancel posting didn't go as far as my response.

The comp.lang.pytho n newsgroup is mirrored by the py*********@pyt hon.org
mailing list, so canceling a message often won't work for the mailing list
subscribers. Your original message will already have been sent out by
email by the time your cancel message gets through.

--
Richie Hindle
ri****@entrian. com

[Terry Reedy]

"Richie Hindle" <ri****@entrian .com> wrote in message
news:g5******** *************** *********@4ax.c om...

[Isaac]

[...] my post didn't make
sense even to myself. So I cancel that post a minute after making it,
although apparently my cancel posting didn't go as far as my response.

The comp.lang.pytho n newsgroup is mirrored by the py*********@pyt hon.org
mailing list, so canceling a message often won't work for the mailing
list
subscribers. Your original message will already have been sent out by
email by the time your cancel message gets through.

and python-list, along with 1000s of other technical mailing lists, is
mirrored as a news.gname.org newsgroup -- gmane.comp.pyth on.

I cancel about half the messages I start to write -- by hitting delete
instead of send ;-0.

Terry J. Reedy

[Carl Banks]

Richie Hindle <ri****@entrian .com> wrote in message news:<ma******* *************** *************** *@python.org>.. .

[Isaac]

[...] my post didn't make
sense even to myself. So I cancel that post a minute after making it,
although apparently my cancel posting didn't go as far as my response.

The comp.lang.pytho n newsgroup is mirrored by the py*********@pyt hon.org
mailing list, so canceling a message often won't work for the mailing list
subscribers. Your original message will already have been sent out by
email by the time your cancel message gets through.

Also, Google ignores cancel requests. If the article makes it to
Google's news server, which it likely will in a matter of seconds,
you're out of luck. Probably the only thing cancel's good for these
days is _immediately_ recalling an incomplete message that you
accidentally clicked post on.

--
CARL BANKS

[Phillip J. Eby]

Ian Bicking <ia**@colorstud y.com> wrote in message news:<ma******* *************** *************** *@python.org>.. .

Jive Dadson wrote:

If you have, for example, several data-types for matrices, how do you
write code that will automatically find the right routine for quickly
multiplying a vector by a diagonal matrix represented as a vector, and
automatically call the right code for multiplying by a sparse matrix
represented by some sparse coding, etc?

I haven't been following this thread, but Phillip Eby's recent
implementation of generic functions should be mentioned if it hasn't
been already:

http://dirtsimple.org/2004/11/generi...ve-landed.html

It might look something like this:

@dispatch.on('m 1', 'm2')
def matrix_mul(m1, m2):
"Multiply two matrices"

@matrix_mul.whe n(VectorMatrix, SparseMatrix)
def matrix_mul_spar se(m1, m2):
"Special implementation"

Actually, it would be more like:

@dispatch.gener ic()
def matrix_mul(m1, m2):
"""Multiply two matrices"""

@matrix_mul.whe n("m1 in VectorMatrix and m2 in SparseMatrix")
def matrix_mul_spar se(m1, m2):
"""Special implementation" ""

The 'dispatch.on()' decorator is for single-dispatch functions only.
If you want to dispatch on multiple arguments or on logical
conditions, you use 'dispatch.gener ic()'. The implementations for
single and multiple dispatch are completely separate, and use
different algorithms.