Await and Defer in Coffeescript core

https://github.com/jashkenas/coffee-script/pull/1942

by DanielRibeiro • 15 years ago

75 25 15 years ago

jashkenas3• 15 years ago

For the curious -- previous discussion about adding TameJS constructs: https://github.com/jashkenas/coffee-script/issues/1710

And the history of a previous attempt at doing something similar:

https://github.com/jashkenas/coffee-script/issues/241

https://github.com/jashkenas/coffee-script/issues/287

https://github.com/jashkenas/coffee-script/issues/350

http://gfxmonk.net/2010/07/04/defer-taming-asynchronous-java...

DanielRibeiro5• 15 years ago

Thanks for the last link[1]. It is pretty amazing. I've studied some Scheme and call/cc on college (and played around with it on Ruby), but this post made me realize how much more powerful can continuations be (besides doing basic control flow/exception stuff).

A post that stands on its own, whether you like/care about Coffeescript/Javascript or not.

[1] http://gfxmonk.net/2010/07/04/defer-taming-asynchronous-java...

KeithMajhor• 15 years ago

Dude you are awesome. I used to think splats and destructuring were what made CoffeeScript more than just pretty Javascript. But this new stuff is doing even more substantive work on our behalves. Thank you.

jashkenas3• 15 years ago

Thank @maxtaco -- TameJS is his baby.

ricardobeat3• 15 years ago

Please, no. I'll stop using coffeescript the day the compiled JS becomes unreadable at first look. A bundled flow-control library with special syntax privileges would be more feasible, and prevent mangling the output.

jashkenas3• 15 years ago

Don't worry -- this is currently just a pull request and a fork that you can try out:

http://search.npmjs.org/#/tamed-coffee-script

The real challenge here is to see if this branch can be made to generate the asynchronous code you would have written in the first place ... or how close we can come to approaching it.

DanielRibeiro5• 15 years ago

I think it is a cool thing to be considered.

Mostly because you can already do it with runtime AST metaprogramming (which is very doable in JS, due to Function.toString, even though is not as easy to do as Lisp/Clojure's macros), and have it as lib.

What the language support adds is simply the convenience of not passing a function with the block of code that will be instrumented. In fact, with language support, you can even debug it.

And the best part about this change: if you don't use it, it will not affect you at all. It is opt-in by default.

Not saying we should take this change lightly, but I believe it does have many merits, and we should not be too quick to dismiss it.

ricardobeat3• 15 years ago

Isn't that achievable by using a symbol that just causes the next adjoined statements to be considered an indent block? Like the inverted or tilde arrow often brought up:

    async.knead flour, water, (err, dough) ~>
    return log err if err?
    async.bake dough, (bread) ~>
    eat bread

BTW, was looking back at the original announcement here at HN, and found this:

    CoffeeScript + node.js + V8 could produce one amazing
    language and implementation.

Little did he know... http://news.ycombinator.com/item?id=1014080

politician• 15 years ago

Would your opinion change if you could debug CS natively?

ghotli• 15 years ago

How would this even work? I'm curious.

ricardobeat3• 15 years ago

Probably not. I still think in javascript and rely on the assumption that I can peek at the compiled output anytime. Looking forward for source-mapping though :)

pkulak• 15 years ago

Is this just saving some tabs, or is it cooler than that? Will a return return to the top function? Will exceptions get caught across callback boundaries?

ericflo2• 15 years ago

This is a game changer, in my opinion.

jnbiche• 15 years ago

Positive or negative?

ericflo2• 15 years ago

Positive.

extension• 15 years ago

The defer syntax feels wrong to me, I think because it looks like a function call but doesn't behave like one (because it assigns to its arguments). If it behaves different then it should look different.

Since it creates a continuation, perhaps it should resemble the syntax for creating a function, like this:

    await resolve "host.com", (ip, err) ~>
    console.log "#{ip} #{err}"

or this:

    await resolve "host.com", (ip, err) <-
    console.log "#{ip} #{err}"

Introducing an operator like this would also avoid some name collisions.

And does the callcc really have to be able to assign to things? Make it work just like a formal parameter list, and then you can actually compile it into one, avoiding all that pass-by-reference hoopla.

The autocb thing is even weirder. Magic variable names? I've never heard of a language that resorted to this. Why not just some new syntax to mark a parameter as the callback? Perhaps some postfix modifier, to match the splat syntax?

    resolve = (host, callback <-) ->
      ...
      return ip, err

or overload a keyword?

    resolve = (host, return callback) ->
      ...
      return ip, err

DanielRibeiro5• 15 years ago

If I understood correctly, they would become keywords, like 'return', 'true', 'false' are in javascript, and 'class' is in coffeescript. The problem with it is that any functions called defer would have to be renamed in order to work on this version of Coffeescript, possibly breaking some existing code.

tikhonj• 15 years ago

This is really pedantic, but I also think it's important: class is a keyword (well, really just a reserved word) in JavaScript as well. The reason it's important is that some engines will actually have issues if you use syntax like this[1]:

    var obj = {class : "blarg"};

[1]: https://developer.mozilla.org/en/JavaScript/Reference/Reserv...

mjor• 15 years ago

I love CoffeeScript, and I would hate to see this become part of the language specification.

Just a few things off the top of my head:

- Why does defer() look like any other function.

- Completely changing the return keyword's meaning if "autocb" is a function argument is just silly.

- The generated JavaScript is utterly unreadable and unquestionably comes with a performance trade-off.

arocks• 15 years ago

For those who didn't understand the new constructs, the following excerpt from TameJS[1] website helps:

> `await` marks a section of code that depends on externals events, like network or disk activity, or a timer. An `await` block contains one or more calls to `defer`. Calling `defer` constructs a new deferral. Only once all deferrals inside an await block are fulfilled does control continue past it. `defer()` behaves much like a normal function; it returns an anonymous function that you give to your async functions. These functions "fulfill" their deferrals by calling the callbacks passed to them.

[1] http://tamejs.org/

equark• 15 years ago

Does this work with the Promise API without defer?

Await and Defer in Coffeescript core

Related Stories