Re: Q: access to subprogram

[bobduff@world.std.com (Robert A Duff)]

In article <ROGOFF.96Jul26095803@sccm.Stanford.EDU>,
Brian Rogoff <rogoff@sccm.stanford.edu> wrote:
>I think that you posted that you like Smalltalk blocks a lot, which are 
>essentially just anonymous closures, right? 

Yes, I did post that.  But it's not because they are full closures --
almost all of the uses in my code, and almost all of the uses I've seen,
are the downward kind.  The reason I like them is that you can do things
like iterators without a lot of fuss.  In Pascal, using the
procedures-as-parameters method, you have to write a procedure for the
body of the loop, and you have to give it a name.  In Ada, using the
generics method, you have to do that, and you also have to write a
generic instantiation, and give *that* a name.  You end up cluttering
the program with useless names for things that should really be
anonymous (The_Loop_Body, or Do_One_Item, or whatever).  So, I like
Smalltalks blocks because they are anonymous.

I also like them because they are written in line.  When I write a loop,
I want to write the iteration stuff controlling the loop, and then I
want the repeated statements to be inside the loop.  The
procedures-as-params solution forces a weird ordering in the code.

>....I think the beauty of this 
>construct is that you can implement lots of features cleanly in terms of 
>it, like control structures. 

No, that merely requires downward closures.  I'm still looking for an
example that really makes the upward direction look wonderfully
powerful.

>...Also the implementation of closures on objects 
>seems heavy/verbose to me.

True.  But that's OK, unless full closures are really as powerful and
commonly needed as I've heard.  Also, the heavy/verbose way of doing it
has an advantage -- it makes quite clear which data is going to survive
the return of this procedure (by being attached to a closure), as
opposed to purely "local" data.

- Bob