Re: Generators/coroutines in future Ada?

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

On 11.07.17 22:25, Dmitry A. Kazakov wrote:
> On 2017-07-11 21:22, J-P. Rosen wrote:
>> Le 11/07/2017 à 20:36, Victor Porton a écrit :
>>> This state also includes the point of execution (like "We are in the second
>>> loop in its second operator.")
>>>
>>>> This can easily be achieved with a function within a package, where the
>>>> package serves to protect and hide the function's state.
>>> Ada currently has no support to save such (point of execution) states.
>> It has. Make your generator a task, and have an accept when the data is
>> ready, which can be nested as deep as you want in any construct.
>>
>> A task is a perfect abstraction for a thread of control that maintains
>> its own execution state!
>
> Except that no control is required.
>
> 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);

If, then, so-called "elegance" of side-effect generating functions
(or of some equivalent operator) is required for reasons of
socially acceptable expression, to make generators visible,
the above pattern should be integrated with some special iteration
scheme like Ada now has in "for ... of ... loop".

Not surprisingly, I think, Icon's generators are available to
use in while-loops that look perfectly ordinary. If Ada requires
generators to be more explicit:

    G     : Stateful := Strings.Find
               (Subject => "...",
               Pattern => "___");

    while X of G with condition (X) loop    -- not Ada
       ...
    end loop;

"while ... of ... with" then requires G to be a Stateful.
Presence of special syntax is, as previously, HOL.

__
(*) Only if the type is special this can make any sense.
E.g., calling Current twice should raise an exception.
That's unlikely to happen if there is special Ada syntax tied
to Stateful, hence "while ... of ... with".