<div class="gmail_quote"><div class="im">For any features to be added to the language, nothing is really about opinion. It all start with use cases.<br>Could you show something that 'delay' enables that is not possible currently? <div>
<font color="#000000"><font><br>
</font></font></div></div><div>Yes, I can. The reason and main use case why I'm requesting <span style>delay </span>is, that I want be able to run node.js modules in the browser without any modification or trickery. I want be able to make a <span style>require function that is synchronous but does not block.</span></div>

<div><span style><br></span></div><div><span style>With the delay keyword, this would look like this:</span></div><div><span style><br>
</span></div><div><div style><font face="courier new, monospace">function loadModule(name,cb){</font></div><div style><font face="courier new, monospace"><span style="white-space:pre-wrap"> </span>setTimeout(function(){</font></div>

<div style><font face="courier new, monospace"><span style="white-space:pre-wrap">                </span>cb({/*my aswesome module*/});</font></div><div style>
<font face="courier new, monospace"><span style="white-space:pre-wrap"> </span>},0);</font></div><div style><font face="courier new, monospace">}</font></div><div style>
<font face="courier new, monospace">function requiure(name){</font></div><div style><font face="courier new, monospace"><span style="white-space:pre-wrap">   </span>var module;</font></div>
<div style><font face="courier new, monospace"><span style="white-space:pre-wrap">        </span>loadModule(name,function(m){</font></div><div style>
<font face="courier new, monospace"><span style="white-space:pre-wrap">         </span>module = m;</font></div><div style><font face="courier new, monospace"><span style="white-space:pre-wrap">       </span>});</font></div>
<div style><span style="white-space:pre-wrap"><font face="courier new, monospace">        </font></span></div><div style><font face="courier new, monospace"><span style="white-space:pre-wrap">  </span>while(!module){</font></div>

<div style><font face="courier new, monospace"><span style="white-space:pre-wrap">                </span>delay;</font></div><div style><font face="courier new, monospace"><span style="white-space:pre-wrap">    </span>}</font></div>
<div style><font face="courier new, monospace"><span style="white-space:pre-wrap">        </span>return module;<span style="white-space:pre-wrap">  </span></font></div>
<div style><font face="courier new, monospace">}</font></div><div style><font face="courier new, monospace"><br></font></div><div style>
<font face="courier new, monospace">var myawesomemodule = require("myawesomemodule"); //non-blocking!</font></div><div style><font face="courier new, monospace"><br></font></div>
<div style><font face="arial, helvetica, sans-serif">With generators, a synchronous but non-blocking require function is simply not possible. You'd have to modify all your code and add everywhere before "require" the "yield" keyword. But that's not all! You'd have to wrap every module definition with another function, which is an absolute pain.</font></div>

<div style><font face="arial, helvetica, sans-serif"><br></font></div><div style><font face="arial, helvetica, sans-serif">So you see, the node.js module loading problem is not resolvable using generators. So, when such a simple thing is not possible using generators, what are they good fore again?</font></div>

<div style><font face="arial, helvetica, sans-serif"><br></font></div><div style><font face="arial, helvetica, sans-serif">The fibonacci example on MSD doesn't really point that out. Except code pausing, all that generators can do can also be done otherwise. I've rewirtten the fibonacci example to demonstrate that:</font></div>

<div style><div><font face="courier new, monospace">function fibonacci(){  </font></div><div><font face="courier new, monospace"><span style="white-space:pre-wrap">      </span>var fn1 = 1;  </font></div>
<div><font face="courier new, monospace"><span style="white-space:pre-wrap">      </span>var fn2 = 1;</font></div><div><font face="courier new, monospace"><span style="white-space:pre-wrap">    </span>return{</font></div>
<div><font face="courier new, monospace"><span style="white-space:pre-wrap">              </span>next:function(){</font></div><div><font face="courier new, monospace"><span style="white-space:pre-wrap">                        </span>var current = fn2;  </font></div>

<div><font face="courier new, monospace"><span style="white-space:pre-wrap">                      </span>fn2 = fn1;  </font></div><div><font face="courier new, monospace"><span style="white-space:pre-wrap">                    </span>fn1 = fn1 + current;  </font></div>

<div><font face="courier new, monospace"><span style="white-space:pre-wrap">                      </span>return current;</font></div><div><font face="courier new, monospace"><span style="white-space:pre-wrap">         </span>}</font></div>
<div><font face="courier new, monospace"><span style="white-space:pre-wrap">      </span>}</font></div><div><font face="courier new, monospace">}</font></div></div><div style>
<br></div><div style>So, the only "new" thing we got from generators is code pausing. But as we have seen above, this is in the current form also useless, since we are still unable to make node.js like modules possible.</div>
<div class="im">
<div style><br></div><div><span style="color:rgb(34,34,34);font-family:arial,sans-serif;font-size:13px;background-color:rgb(204,204,204)"> coroutines would require to store stack frames to enable running them later.</span>
</div><div><span style="color:rgb(34,34,34);font-family:arial,sans-serif;font-size:13px;background-color:rgb(204,204,204)"><br></span></div></div><div><font color="#222222" face="arial, sans-serif"><span style>This is also true for generators. The only difference is, that the stored stack is never deeper that one function call. So, theoretically, every engine that curently supports "yield" should also be able to store a bigger stack.</span></font></div>

<div><font color="#222222" face="arial, sans-serif"><span style><br></span></font></div><div><font color="#222222" face="arial, sans-serif"><span style>But ok, if it's this limitation to flat stacks that excites you about generators, I got another idea how we could mix "delay" and generators to something that makes a lot of sense. What about adding the functions "callDelayed" and "applyDelayed" to the Function prototype? The would do exactly the same as "call" and "apply" but with the difference, that they don't return the result. Instead the return an object that has a synchronous property "result" or a function "getResult()" and a function "continue()". After accessing "result", the code pauses until the function returns a value. In functions, we still would have the "delay" keyword. But instead of moving the current stack to the end of the queue, it would remain paused until someone calls "continue()"</span></font></div>

<div><br></div><div><font color="#222222" face="courier new, monospace">function a(){</font></div><div><font color="#222222" face="courier new, monospace">    delay;</font></div><div><font color="#222222" face="courier new, monospace">    return "Hello World";</font></div>

<div><font color="#222222" face="courier new, monospace">}</font></div><div><font color="#222222" face="courier new, monospace">var functioncall = a.callDelayed(this);</font></div><div><font color="#222222" face="courier new, monospace">setTimeout(function(){</font></div>

<div><font color="#222222" face="courier new, monospace">     functioncall.continue();</font></div><div><font color="#222222" face="courier new, monospace">},0);</font></div><div><font color="#222222" face="courier new, monospace">console.log(functioncall.result); //pauses until "continue()" was called, then displays "Hello World"</font></div>

<div><br></div><div><font color="#222222" face="arial, helvetica, sans-serif">To me, all this is not a feeling- or optinion- thing. I just see that I can't do what I want do without co-routines. There's definitely a usecase for them. There are things co-routines can do, that generators can't.</font></div>

<div><font color="#222222" face="arial, helvetica, sans-serif"><br></font></div><div><br></div><div><font color="#222222" face="arial, helvetica, sans-serif">Please note that I'm not really interested in programming new stuff in a new way. I was really happy with the current JavaScript. The only bad thing was, that we were not able to load code synchronously but non-blocking. To make for example node.js modules working in the browser, we needed to rewrite them or to use some trickery. So, I don't wan't to introduce a new coding style with "delay", I just want to make <b>existing code</b> work using some new features.</font></div>

<div><font color="#222222" face="arial, helvetica, sans-serif"><br></font></div><div><font color="#222222" face="arial, helvetica, sans-serif">Generators instead are tought to introduce a new way of coding. But since we were able to do exactly the same in the past using different syntax, it isn't a really needed feature. <b>Except of the code pausing using yieald, tough.</b></font></div>

<div><font color="#222222" face="arial, helvetica, sans-serif"><b><br></b></font></div><div><font color="#222222" face="arial, helvetica, sans-serif"><b><br></b></font></div><div><font color="#222222" face="courier new, monospace"><br>

</font></div><div><font color="#222222" face="courier new, monospace"><br></font></div><div><font color="#222222" face="arial, sans-serif"><br></font></div><div style><br></div></div><div class="HOEnZb"><div class="h5"><div>

<br><div class="gmail_quote">2012/7/5 David Bruant <span dir="ltr"><<a href="mailto:bruant.d@gmail.com" target="_blank">bruant.d@gmail.com</a>></span><br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">


  
    
  
  <div bgcolor="#FFFFFF" text="#000000">
    <div>Le 05/07/2012 11:08, Patrik Stutz a
      écrit :<br>
    </div><div>
    <blockquote type="cite"><font color="#000000"><font><font face="verdana,sans-serif">I've read the articles you linked
            to and still think that 'delay' would be a great idea! I
            think </font></font></font><a href="http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-web/" style="color:rgb(17,85,204);font-size:13px;font-family:arial,sans-serif" target="_blank">this</a> post
      is wrong in many things. In my opinion, "coroutines" would be even
      simpler to implement (depending on the current design of the
      engine).</blockquote></div>
    I am not a JavaScript engine implementors (Dave Herman is, by the
    way), but from what I know, coroutines would require to store stack
    frames to enable running them later. If it's not something done
    already, it may be complicated to do. JavaScript engines are
    engineered for performance of today's JavaScript and today, there is
    no coroutine (this probably stands for generators, but some engines
    already have generators)<div><br>
    <br>
    <blockquote type="cite">Also, using generators is complicated as hell and in
      the end still does nothing useful since "yield" is not asynchronus
      at all. All the libraries that use generators do a lot to make you
      feel like it were asynchronous behind the scenes, but it isnt.
      <div>
        <font color="#000000"><font><br>
          </font></font></div>
      <div><font color="#000000"><font>Do you really want to add a
            feature to JavaScript, for that you need a complicated
            library to use it? And even with such a library, it's still
            much more complicated to use than a simple "delay" keyword.</font></font></div>
      <div><font color="#000000"><font><br>
          </font></font></div>
      <div><font color="#000000"><font>While generators & libraries
            for it would overcomplicate JavaScript, "delay" would be
            dead simple to use. It would fit much better into the
            language since the rest of the language is also designed
            very simple.</font></font></div>
    </blockquote></div>
    Your post contains a lot of opinions, feelings and things that you
    think and adding new features is not really about what a particular
    person thinks in my opinion.<br>
    For any features to be added to the language, nothing is really
    about opinion. It all start with use cases.<br>
    Could you show something that 'delay' enables that is not possible
    currently?<br>
    For instance, private names cannot be implemented today and they
    answer to a need of JavaScript developers who want better
    encapsulation idioms.<br>
    <br>
    If there is no such thing, is it a major improvement by comparison
    to what is possible today?<br>
    For instance, WeakMaps, Maps and Sets can actually be implemented
    today, but with bad performances or relying on mechanisms with
    unreliable performance, so having them implemented in the language
    offers some guarantees of performance.<br>
    <br>
    <br>
    I am not asking for yes/no answers, but actual code snippets taken
    out of real projects showing how 'delay' would make the code easier
    to read or understand, to reason about.<br>
    <br>
    <br>
    One point made by Dave in his article is very compelling:<br>
    "Once you add coroutines, you never know when someone might call
    <code>yield</code>. Any function you call has the right to pause and
    resume you
    whenever they want".<br>
    => This makes very difficult to build programs using libraries.<br>
    <br>
    "Generators are a lot like coroutines, with one important
    difference: they only suspend their own function activation."<br>
    => And suddenly, your code is not affected by another function
    being a generator. When you call a function, it either never return
    (infinite loop), returns or throws an exception (which is just a
    different form of return for that matter).<div><br>
    <br>
    <blockquote type="cite">
      <div><font color="#000000"><font><br>
          </font></font></div>
      <div><span style="color:rgb(34,34,34);font-family:arial,sans-serif;font-size:13px;background-color:rgb(204,204,204)">all
          you'd have change in the example is use something else than
          setTimeout, and make the delay a function call instead..</span>
      </div>
      <div><br>
      </div>
      <div><font face="arial, sans-serif" color="#222222"><span>Cool! But what are
            the alternatives to "setTimeout" on the browser side wich
            dont have any delay?</span></font></div>
    </blockquote></div>
    setTimeout(f ,0) could work, but has a small delay for historical
    reasons.<br>
    Microsoft is coming up with setImmediate (I haven't heard anyone
    following)
<a href="https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/setImmediate/Overview.html" target="_blank">https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/setImmediate/Overview.html</a><br>
    There is also a trick with calling postMessage to send yourself a
    message: <a href="http://dbaron.org/log/20100309-faster-timeouts" target="_blank">http://dbaron.org/log/20100309-faster-timeouts</a><span><font color="#888888"><br>
    <br>
    David<br>
  </font></span></div>

</blockquote></div><br></div>
</div></div></div><br>