post in our series on promises introduced the
async and await commands. That post focused on how these commands
further simplify asynchronous programming with promises.
This post takes a different angle on their utility - how they can
be used to speed up sequential code with minimal effort.
In a series of prior posts, I had introduced the promise
abstraction along with the promise
Tcl package and how it can greatly simplify certain forms of asynchronous
computation. As mentioned there, the Tcl package is roughly based
ES7 introduced the async and await functions which further simplify
asynchronous programming with promises in certain scenarios. Accordingly,
the Tcl promise package has been updated to include the equivalent
commands. This post introduces their use.
In a prior post I had illustrated the
use of the Tcl promise package for asynchronous computing with
some examples. There we had ignored the possibility of errors and
exceptions and how they are handled in promise-based code. In
this post, we build on the examples in that post to illustrate how
promises greatly simplify handling of errors in async code.
I had previously described an experimental
implementation of promises for Tcl. On re-reading my earlier
post, I was somewhat dissatisfied with the treatment there in that
I did not feel it fully reflected the value of the promise
abstraction, getting somewhat caught up in the details. This post
takes a somewhat different approach, concentrating more on
examples and refraining from going into detail about each command
or method. Here I am more interested giving you a flavor of programming
with promises and motivating you to explore further.
This post is obsoleted by the promise
package (based on the code is this post) and by
on the topic. Nevertheless it may still hold some tutorial benefit.
the promise abstraction for asynchronous code. Implemented in
various forms in third party libraries, it proved sufficiently
useful to be formally defined and incorporated into ECMAScript 6.
Other languages, from Python and Scala to C#, C++ and Java, have
implementations of promises in various flavors
(sometimes separated into promises and futures). Not finding one
for Tcl (we cannot let Tcl lag!),
I started on an experimental implementation described in this post.