Re: Proposed change to BC iterator parameters

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

Robert A Duff wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> But Robert wants it in a non-OO way! I think that he's right. The
>> language should support both procedural and OO approaches, for they are
>> complimentary.
> 
> I'm not sure why you call the cursor style "OO".

Cursor is an object! (:-))

> But yes, both styles
> are useful.
> 
> What I *really* want is that the iterator can be written in whichever
> style is appropriate, and easily *used* in either style.  Converting the
> downward closure style to what you call the OO style (which I call the
> cursor style) requires language support for coroutines, or something
> very much like coroutines.

Mmm, I am not sure what you mean. Technically either you pass a callback
subroutine (+ its context) or you do an object (having a dispatching
subroutine), both should be equivalent. The only difference is in syntactic
sugar, i.e. (for cursor/OO approach) how easily one can derive a new type,
override a subprogram, pack the necessary context stuff in a cursor
instance. There should be a lot of sugar (and you have to do it at the
library level, oops!) However, if we could put a subprogram body in an
expression for the closure style, then we could also do it with the body of
a cursor's override. Why not? So in both cases one could jump out of an
iteration/recursion loop. But my concern is that non-local gotos and ad-hoc
exceptions violate contract. Actually there is no any contract of an
anonymous body. It is fine when the program is 50 lines long, but in a
medium-sized project it might become a nightmare. What would your debugger
show in the call-stack window for an anonymous body, after all? (:-))

> You can simulate coroutines using tasks and protected objects, but the
> syntax is over-the-top heavy.  Not to mention the inefficiency.

-- 
Regards,
Dmitry A. Kazakov
www.dmitry-kazakov.de