Re: Generators/coroutines in future Ada?

["G.B." <bauhaus@notmyhomepage.invalid>]

On 12.07.17 09:34, Dmitry A. Kazakov wrote:

>>> I don't understand what is wrong with:
>>>
>>>    type Stateful is limited private;
>>>    function Generate (X : not null access Stateful) return Things;
>>
>> Arguably, first, a "function" lacks query/command separation:
>>
>>     type Stateful is limited interface;
>>     function Current (x : Stateful) return Thing;  -- (*)
>>     procedure Next (x : in out Stateful);
>
> I don't understand this example. Why Next cannot be a part of Current? Example:
>
>    X := Stack.Pop;

It didn't say it can't be.  (Without query/command separation,
one needs access parameters using most versions of Ada, though,
because then a function (query) is not really allowed to modify
_its_ parameters, unlike a procedure (command) that has an in out
parameter.)

Assume that the language has special generator syntax, e.g.:

    while X of Stack with 0 < X and X < 10 loop

This is to mean that generating a value happens once per iteration,
binding the result to the X before *of* and then evaluating the
condition. Stack being a Stateful, it has the prim ops needed.

If X, still a generator, were instead to be repeatedly evaluated,
as in

    while 0 < X and X < 10 loop

then it isn't clear how many values will be generated if,
under the hood, the expression entails evaluating

     0 <Stack.Pop and Stack.Pop < 10.

What about optimizing? Nothing new.

At first sight, this pattern can be expressed by making
a single assignment which has been working even before Ada 83:

     X : Value_Type := Stack.Pop;
     while 0 < X and X < 10 loop

But this pattern can only lead to emulating any number of
particular generator-like objects, not to generators:
no special types, no syntax, hence no support from the compiler.

Note that this argument emphasizes the use of a generator,
not the construct that furnishes it.