220 5249 <291db835-d42d-40cd-8760-47cdf327680d@isocpp.org> article Path: news.gmane.org!not-for-mail From: Xeo Newsgroups: gmane.comp.lang.c++.isocpp.proposals Subject: Re: Some thoughts about coroutines Date: Thu, 27 Jun 2013 01:53:53 -0700 (PDT) Lines: 1439 Approved: news@gmane.org Message-ID: <291db835-d42d-40cd-8760-47cdf327680d@isocpp.org> References: Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/alternative; boundary="----=_Part_87_21569202.1372323233185" X-Trace: ger.gmane.org 1372323233 20728 80.91.229.3 (27 Jun 2013 08:53:53 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Thu, 27 Jun 2013 08:53:53 +0000 (UTC) Cc: asaelr@gmail.com To: std-proposals@isocpp.org Original-X-From: std-proposals+bncBCCNBYNYXMJRBIP3V6HAKGQEH5HTKJQ@isocpp.org Thu Jun 27 10:53:56 2013 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-vb0-f69.google.com ([209.85.212.69]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1Us7xj-0002tH-9U for gclcip-std-proposals@m.gmane.org; Thu, 27 Jun 2013 10:53:55 +0200 Original-Received: by mail-vb0-f69.google.com with SMTP id w16sf739061vbb.0 for ; Thu, 27 Jun 2013 01:53:54 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=x-beenthere:date:from:to:cc:message-id:in-reply-to:references :subject:mime-version:x-original-sender:reply-to:precedence :mailing-list:list-id:x-google-group-id:list-post:list-help :list-archive:list-subscribe:list-unsubscribe:content-type; bh=5E5qHvH0TuKPDX2og4ZM6vZwLANsXx97cZhcecmx/zI=; b=Hl567hq7yLenJRWFMNWcO0dTZFkJi2PM9fM3vJJUcn+e6e6ijBaNu6RbPX2eX3PgN/ vSoMHRE9V+HjqDvr8NkWAPgahspy1O5/zE2d5JgO1bfqKdNb1NmX6oqPGKPC/vaQRotg LcDsd3hg0uy4STHxpoXFxgB+IZZjLNEhTFrwLWggXhHvx5Bh2wVwjAy/SanHbSgwNmvd 1KLUeTMnaBltm6azswrRos9CYN/hgAI8bDxrWZkly5vnmzIYsseIGnlwNC/RNnl4308U q+zc4XFNEZH65/9v7Umf+uKjezQSYvhw4mRy+1p3CCewR8oxFtdPDSqlacymhpM3/RlA IFTQ== X-Received: by 10.236.83.82 with SMTP id p58mr4046579yhe.10.1372323234472; Thu, 27 Jun 2013 01:53:54 -0700 (PDT) X-BeenThere: std-proposals@isocpp.org Original-Received: by 10.49.26.70 with SMTP id j6ls456342qeg.94.gmail; Thu, 27 Jun 2013 01:53:53 -0700 (PDT) X-Received: by 10.49.129.104 with SMTP id nv8mr204783qeb.27.1372323233632; Thu, 27 Jun 2013 01:53:53 -0700 (PDT) In-Reply-To: X-Original-Sender: hivemaster@hotmail.de Precedence: list Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org List-ID: X-Google-Group-Id: 399137483710 List-Post: , List-Help: , List-Archive: List-Subscribe: , List-Unsubscribe: , Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:5249 Archived-At: ------=_Part_87_21569202.1372323233185 Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: quoted-printable While I really want to get my hands on native coroutines, I don't think=20 your approach works very well. 1) Who says we always want to use coroutines as `for(auto r : coro(args))`?= =20 I don't think that's necessarily the main form of use 2) How would the transformation to a class work for template argument=20 deduction? I think a better course would be to transform the return type of such a=20 function, as would be done with async/await-style functions. The returned type would then simply have an `operator()` and if you wanted= =20 a range from that, it could be quite easily done with a general=20 function-adaptor. On Thursday, June 27, 2013 3:40:58 AM UTC+2, asa...@gmail.com wrote: > > Recently, I=92ve thought a lot about coroutines, and how they should beha= ve=20 > if became a part of c++. > > I found two (main) proposals: > > a.=20 > https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/3g6ZIW= edGJ8 > > It has the advantage of not requiring to change the syntax, but in force = a=20 > new model of stack-based calls. It does so in purpose to let nested=20 > functions to yield value, which I think is not really necessary. (If we l= et=20 > nested functions return value on behalf of their callee, we should start= =20 > this in regular functions). Also, Its syntax is somehow complex. > > b.=20 > https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/PPZJVT= DdDVQ > > It is easy to use and doesn=92t require a new stack, and I think that thi= s=20 > is the right direction. However, it ignores some technical details=20 > (lifetime of locals, etc). Also, adding a keyword may break too many=20 > working code, and my personal opinion is that it is ugly. Sentences like= =20 > =93void numbers() yields int=94 reminds me too many things I hate in Java= .. The=20 > alternative syntax (described at the end of this proposal) is not so ugly= ,=20 > but still complex. > > There is even a nice implementation of coroutines (using macros):=20 > http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html > > but it has 2 major disadvantages: while using it, we can=92t yield a valu= e=20 > from within a switch statement, and, much more important, we have to defi= ne=20 > all the local variables at the top of the function - back to C90 days! (a= nd=20 > with constructors this is much worst.) > > Another thing that was very little talk about, is for-range loops native= =20 > support. Let=92s say we have a Fibonacci number generator (a very common= =20 > example): > > (Using Denis Bredelet=92s proposal syntax) > > void fib(int n) yields int { > > int a=3D0,b=3D1; > > while(n--) { > > int c=3Da+b; > > a=3Db; > > b=3Dc; > > yield c; > > } > > } > > We want the possibility to write for (int i : fib(10)) std::cout< > So what am I suggest? > > First, to the syntax. Since we want it to work natively with for-range=20 > loops, and since the language concept is =93declare it the way you will = use=20 > it=94, I would suggest using colon in the function signature. The nicest = idea=20 > I managed to think so far is int : fib(int n) > > Also, there is no reason to add the keyword yield, when we can stick to= =20 > good old return. > > Now, to the real stuff: What does fib(10) mean? What=92s the type of=20 > fib(10).begin()? > > I suggest this meaning: fib will be (auto-generated) class, and an object= =20 > of it will represent calling the =93function=94 with specific parameters.= The=20 > member function begin (and end) will return some sort of iterator, which= =20 > will represent the actual call. > > Some details: the fib class should have some members, to contain the=20 > parameters it called with, but the real fun is in the iterator class: it= =20 > will have (in addition to the parameters), as (not exactly, I will expla= in=20 > below) members, all the local variables of the =93function=94 (including = the=20 > return value), and also the information about where it stopped last time= =20 > (and should resume from) - let=92s call it, from now on, =93position data= =94. > > To be more precise: an iterator should contain the memory for the local= =20 > variables (like every member variable), but their lifetime will be as if= =20 > they were local variables of the =93function=94. I mean - they will been= =20 > constructed only when the =93function=94 will decide so, and not automati= cally=20 > when the iterator is been constructed. > > When the =93function=94 ends (either by falling through the ending brace,= not=20 > catching exception, or simply saying return; without a value), the=20 > position data should contain this information, and (like every function),= =20 > every local variable should be destructed. > > Knowing the position data let us easily determine which variables are=20 > alive, and so I think that the following member functions can be=20 > automatically created: > > copy constructor - should copy the position data, the parameters, and=20 > every living local variable > > move constructor - the same, but move instead of copy > > destructor - destroy the parameters, and every living local variable. > > (Of course, if some local variable is noncopyable, so is the iterator) > > I think that it should not be assignable - If one iterator have a live=20 > object, and another one have not, it=92s a real mess. > > Some example: > > Suppose that we want to yield the number 0, and then, the first n=20 > Fibonacci numbers and the first n even number, alternately. To add more= =20 > interest (and to demonstrate more rules), I want to create and destroy so= me=20 > objects (assume A is a copyable, moveable, and int-constructive class),= =20 > so I=92ve written the following code: > > int : fib_even(int n) { > > A a(7); > > int fib1=3D0,fib2=3D1,even=3D0; > > return 0; > > while(n--) { > > int fib3=3Dfib1+fib2; > > fib1=3Dfib2; > > fib2=3Dfib3; > > return fib3; > > A b=3Dn; > > return even+=3D2; > > } > > } > > A compiler may expand it to something like: > > (Note: I=92m using dynamic memory allocation, but It=92s not really how i= t=20 > should be implemented - I just don=92t want some constructors and destruc= tors=20 > to been invoked automatically) > > class fib_even { > > class iterator { > > int n; > > int *fib1,*fib2,*fib3,*even; > > A *a,*b; > > int *ret_value; > > enum {p0,p1,p2,p3,p4} pos; //resuming points > > void next() { > > switch (pos) { > > case p0: break; > > case p1: goto label1; > > case p2: goto label2; > > case p3: goto label3; > > case p4: return; > > } > > //construct automatic variables of the function > > a=3Dnew A(7); > > fib1=3Dnew int(0); > > fib2=3Dnew int(1); > > even=3Dnew int(0); > > //the return process - create the value, save the resuming point, and=20 > return > > ret_value=3Dnew int(0); > > pos=3Dp1; > > return; > > label1: > > while(n--) { > > fib3=3Dnew int(*fib1+*fib2); //being constructed only now > > *fib1=3D*fib2; > > *fib2=3D*fib3; > > ret_value=3Dnew int(*fib3); > > pos=3Dp2; > > return; > > label2: > > b=3Dnew A(n); > > ret_value=3Dnew int((*even)+=3D2); > > pos=3Dp3; > > return; > > label3: > > //automatic variables going out of scope, and should be destructed > > delete b; > > delete fib3; > > } > > delete even; > > delete fib2; > > delete fib1; > > delete a; > > pos=3Dp4; > > } > > iterator(int n) : n(n),pos(p0) { > > next(); //get the first value > > } > > iterator() : pos(p4) {} > > public: > > iterator &operator++() { > > delete ret_value; > > next(); > > return *this; > > } > > int &operator*() { > > return *ret_value; > > } > > iterator(const iterator &it) : n(it.n),pos(it.pos) { > > //copy only living members > > if (pos>p0 && pos > ret_value=3Dnew int(*it.ret_value); > > a=3Dnew A(*it.a); > > fib1=3Dnew int(*it.fib1); > > fib2=3Dnew int(*it.fib2); > > even=3Dnew int(*it.even); > > } > > if (pos>p1 && pos > if (pos>p2 && pos > } > > iterator(iterator &&it) : n(std::move(it.n)),pos(it.pos) { > > if (pos>p0 && pos > ret_value=3Dnew int(std::move(*it.ret_value)); > > a=3Dnew A(std::move(*it.a)); > > fib1=3Dnew int(std::move(*it.fib1)); > > fib2=3Dnew int(std::move(*it.fib2)); > > even=3Dnew int(std::move(*it.even)); > > } > > if (pos>p1 && pos > if (pos>p2 && pos > } > > ~iterator() { > > if (pos>p2 && pos > if (pos>p1 && pos > if (pos>p0 && pos > delete even; > > delete fib2; > > delete fib1; > > delete a; > > delete ret_value; > > } > > } > > bool operator!=3D(const iterator &it) { > > return pos!=3Dit.pos; > > } > > operator bool() { > > return pos > } > > iterator &operator=3D(const iterator&) =3D delete; > > friend fib_even; > > }; > > int n; > > public: > > fib_even(int n) : n(n) {} > > iterator begin() { > > return iterator(n); > > } > > iterator end() { > > return iterator(); > > } > > }; > > So, what do you think? > --=20 ---=20 You received this message because you are subscribed to the Google Groups "= ISO C++ Standard - Future Proposals" group. To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposals+unsubscribe@isocpp.org. To post to this group, send email to std-proposals@isocpp.org. Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa= ls/. ------=_Part_87_21569202.1372323233185 Content-Type: text/html; charset=windows-1252 Content-Transfer-Encoding: quoted-printable While I really want to get my hands on native coroutines, I don't think you= r approach works very well.

1) Who says we always want to use corout= ines as `for(auto r : coro(args))`? I don't think that's necessarily the ma= in form of use
2) How would the transformation to a class work for templ= ate argument deduction?

I think a better course would be to transfor= m the return type of such a function, as would be done with async/await-sty= le functions.
The returned type would then simply have an `operator()` a= nd if you wanted a range from that, it could be quite easily done with a ge= neral function-adaptor.

On Thursday, June 27, 2013 3:40:58 AM UTC+2,= asa...@gmail.com wrote:

Recently, I=92ve thought a lot about = coroutines, and how they should behave if became a part of c++.

<= p dir=3D"ltr" style=3D"line-height:1.15;margin-top:0pt;margin-bottom:0pt"><= span style=3D"font-size:15px;font-family:Arial;color:#000000;background-col= or:transparent;font-weight:normal;font-style:normal;font-variant:normal;tex= t-decoration:none;vertical-align:baseline">I found two (main) proposals:

a. https://groups.google.com/a/isocpp.org/for= um/#!topic/std-proposals/3g6ZIWedGJ8

It has the advantage of not requiring to change the syntax, but in force a new model of stack-based calls. It does so in purpose to let nested=20 functions to yield value, which I think is not really necessary. (If we=20 let nested functions return value on behalf of their callee, we should=20 start this in regular functions). Also, Its syntax is somehow complex.

b. https://groups.google.com/a/isocpp.org/forum= /#!topic/std-proposals/PPZJVTDdDVQ

I= t is easy to use and doesn=92t require a new stack, and I think that this=20 is the right direction. However, it ignores some technical details=20 (lifetime of locals, etc). Also, adding a keyword may break too many=20 working code, and my personal opinion is that it is ugly. Sentences like =93void numbers() yields int=94 reminds me too many things I hate in Java.= =20 The alternative syntax (described at the end of this proposal) is not so ugly, but still complex.

There is even a nice implementation of coroutines (using macros): http://www.chiark.greenend.org.uk/~sgtatham/c= oroutines.html<= /span>

but it has 2 major disadvantages: while using it, we can=92t yield a value=20 from within a switch statement, and, much more important, we have to=20 define all the local variables at the top of the function - back to C90=20 days! (and with constructors this is much worst.)


Another thing that was very little talk about, is for-range loops native=20 support. Let=92s say we have a Fibonacci number generator (a very common=20 example):

(Using Deni= s Bredelet=92s proposal syntax)

void fib(int n) yields int {

 int a=3D0,b=3D1;

 while(n--) {

   int c=3Da+b;

   a=3Db;

   b=3Dc;

   yield c;

 }

}

We want the possibility to write for (int i : fib(10)) std::cout<<i<&= lt;=92\n=92; to print th= e first 10 Fibonacci numbers.


So what am = I suggest?

First, to the syntax. Since we want it to work natively with for-range loops,=20 and since the  language concept is =93declare it the way you will use = it=94, I would suggest using colon in the function signature. The nicest idea I managed to think so far is int : fib(int n)

= Also, there is no reason to add the keyword yield, when we can stick to good old return.<= /p>

Now, to the real stuff: What= does fib(10) mean? What=92s the type of = fib(10).begin()?

I suggest this meaning: fib will be (auto-generated) class, and an object of it will represent calling the =93function=94 with specific parameters.= =20 The member function begi= n (and end) will return some sort of iterator, which will represent the = actual call.

Some det= ails: the fib class should have some members, to= contain the parameters it called with, but the real fun is in the <= span style=3D"font-size:15px;font-family:Arial;color:#000000;background-col= or:transparent;font-weight:normal;font-style:italic;font-variant:normal;tex= t-decoration:none;vertical-align:baseline">iterator class: it will have (in addition to the parameters),  as (not exactly= , I will explain below) members, all the local variables of the =93function=94= =20 (including the return value), and also the information about where it=20 stopped last time (and should resume from) - let=92s call it, from now on, =93position data=94.

To be more precise: an = iterator should contain the memory for the local variables (like every member=20 variable), but their lifetime will be as if they were local variables of the =93function=94. I mean - they will been constructed only when the=20 =93function=94 will decide so, and not automatically when the iterator is been constructed.

When the =93function=94 ends (either by falling thr= ough the ending brace, not catching exception, or simply saying return; without a value), the position data should contain this information,=20 and (like every function), every local variable should be destructed.

Knowing the position data let us easily determine which variables are alive,=20 and so I think that the following member functions can be automatically=20 created:

copy constru= ctor - should copy the position data, the parameters, and every living loca= l variable

move const= ructor - the same, but move instead of copy

destructor - destroy the parameters, and every livi= ng local variable.

(O= f course, if some local variable is noncopyable, so is the iterator)=

I think that it should not = be assignable - If one iterator have a live object, and another one have no= t, it=92s a real mess.


Some example:

Suppose that we want to yield the number 0, and then, the first n Fibonacci=20 numbers and the first n even number, alternately. To add more interest=20 (and to demonstrate more rules), I want to create and destroy some=20 objects (assume A= is a copyable, moveable, and i= nt-constructive class), so I=92ve written the following code:

int : fib_even(int n) {

=

=    A a(7);

   int fi= b1=3D0,fib2=3D1,even=3D0;

   return 0;

   while(n--) {

       int fib3=3Dfi= b1+fib2;

  = ;     fib1=3Dfib2;

       fib2=3Dfib3;=

    &n= bsp;  return fib3;

       A b=3Dn;

       return e= ven+=3D2;

 &nbs= p; }

}

A compiler may expand it to something like:=

(Note: I=92m using dynamic memory allocation, but It=92s not really how it should= =20 be implemented - I just don=92t want some constructors and destructors to= =20 been invoked automatically)


class fib_eve= n {

  &nbs= p;class iterator {

&= nbsp;      int n;

       int *fib1,*fi= b2,*fib3,*even;

&nbs= p;      A *a,*b;

       int *ret_value;<= /span>

   &n= bsp;   enum {p0,p1,p2,p3,p4} pos; //resuming points

     = ;  void next() {

           switch (pos) {

   &nbs= p;           case p0: break;=

    &n= bsp;          case p1: goto label1;

    =            case p2: goto label2;

   &nbs= p;           case p3: goto label3;<= /span>

   &n= bsp;           case p4: return;

    = ;       }

//construct automatic variables of the function

          &nb= sp;a=3Dnew A(7);

&nb= sp;          fib1=3Dnew int(0);

    = ;       fib2=3Dnew int(1);

       &nbs= p;   even=3Dnew int(0);

//the retur= n process - create the v= alue, save the resuming = point, and return

           ret_value=3Dnew i= nt(0);

  &= nbsp;        pos=3Dp1;

       &nbs= p;   return;

       label1:

       &nbs= p;   while(n--) {

             = ;  fib3=3Dnew int(*fib1+*fib2); //being constructed only now

    &= nbsp;          *fib1=3D*fib2;

=

=      =          *fib2=3D*fib3;

      &nbs= p;        ret_value=3Dnew int(*fib3);<= /p>

    &nb= sp;          pos=3Dp2;

       = ;        return;

       label2:

    = ;           b=3Dnew A(n);

     = ;          ret_value=3Dnew int((*even)+= =3D2);

  &= nbsp;            pos=3Dp3;

    = ;           return;

      &nbs= p;label3:

//automatic= variables going out of scope, and should be des= tructed

 &n= bsp;             delete b= ;

   =             delete fib3;

    &= nbsp;      }

           delete= even;

  &= nbsp;        delete fib2;

       &n= bsp;   delete fib1;

           delete a;=

   &= nbsp;       pos=3Dp4;

       }

     = ;  iterator(int n) : n(n),pos(p0) {

          &nbs= p;next(); //get the firs= t value

 &n= bsp;     }

       iterator() : pos(p4) {}

   publi= c:

   = ;    iterator &operator++() {

        &nb= sp;  delete ret_value;

           next();

    = ;       return *this;

       }

     = ;  int &operator*() {

           return *= ret_value;

 &nb= sp;     }

       iterator(const iterator &= ;it) : n(it.n),pos(it.pos) {

//copy only living members

           = if (pos>p0 && pos<p4) {

           &= nbsp;   ret_value=3Dnew int(*it.ret_value);

       &nbs= p;       a=3Dnew A(*it.a);

       &nbs= p;       fib1=3Dnew int(*it.fib1);

      &nbs= p;        fib2=3Dnew int(*it.fib2);

     = ;          even=3Dnew int(*it.even);

    = ;       }

           if (= pos>p1 && pos<p4) fib3=3Dnew int(*it.fib3);

       = ;    if (pos>p2 && pos<p4) b=3Dnew A(*it.b);

   &nb= sp;   }

&n= bsp;      iterator(iterator &&it) : n(std:= :move(it.n)),pos(it.pos) {

           if (pos>p= 0 && pos<p4) {

              =  ret_value=3Dnew int(std::move(*it.ret_value));

       &nbs= p;       a=3Dnew A(std::move(*it.a));

      &= nbsp;        fib1=3Dnew int(std::move(*it.fib= 1));

  &nb= sp;            fib2=3Dnew int(= std::move(*it.fib2));

              &nbs= p;even=3Dnew int(std::move(*it.even));

           = }

   =         if (pos>p1 && pos<p4) f= ib3=3Dnew int(std::move(*it.fib3));

           if = (pos>p2 && pos<p4) b=3Dnew A(std::move(*it.b));

      &n= bsp;}

  &n= bsp;    ~iterator() {

           if= (pos>p2 && pos<p4) delete b;

          =  if (pos>p1 && pos<p4) delete fib3;

       &nb= sp;   if (pos>p0 && pos<p4) {

       &nbs= p;       delete even;

         = ;      delete fib2;

           = ;    delete fib1;

            =    delete a;

              &nb= sp;delete ret_value;

=            }

       = ;}

   = ;    bool operator!=3D(const iterator &it) {

<= p dir=3D"ltr" style=3D"line-height:1.15;margin-top:0pt;margin-bottom:0pt"><= span style=3D"font-size:15px;font-family:Arial;color:#000000;background-col= or:transparent;font-weight:normal;font-style:normal;font-variant:normal;tex= t-decoration:none;vertical-align:baseline">       =      return pos!=3Dit.pos;

       }

     = ;  operator bool() {

           return pos<= ;p4; //still hasn't ende= d

  &n= bsp;    }

       iterator &operator=3D(const i= terator&) =3D delete;

       friend fib_even;

   };

   int n;

public:

   fib_even(int n) : n(n) = {}

   = ;iterator begin() {

=        return iterator(n);

   }

   iterator end() {

   &nb= sp;   return iterator();

   }

};


=

So, what do you think?

--
 
---
You received this message because you are subscribed to the Google Groups &= quot;ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposals/<= /a>.
 
 
------=_Part_87_21569202.1372323233185-- .