avenir

Lightweight async library based on lazy Futures. Inspired by
folktale's Data.Task

The library provides Tasks for writing asynchronous code with JavaScript in
Node and the Browser.

Unlike Promises, Tasks are lazy and cancellable.

avenir Tasks differ also in a few point from folktale Data.Task.

For more details, see comparison.

Rationale

Consider the following example using Promises

var promiseA = someAsynFn()
var promiseB = promiseA.then(...)

Let's suppose that Promises were given builtin cancellation. And that we invoke
promiseB.cancel(). The question is how do we interpret the effects of this
cancellation ?

1. Should we only cancel promiseB and not touch promiseA ?
2. Or should we also cancel promiseA ?

In case of (1) then what if the code represented an atomic operation ? In this
case a cancellation means cancelling the whole operation and this implies
cancelling also promiseA if it's still pending.

Note that even of we write it inline like this

var promiseB = someAsynFn().then(...)

There is no way we can infer the atomicity of the operation because Promises are
immutables and each invocation of then returns a new Promise. The new Promise
itself is not aware of how it was derived.

Now if we choose (2) and cancel the whole chain, then imagine there is another
operation that was attached to promiseA (or that will be attached in some point
of the future[no pun intended] in our code).

var promiseA = someAsynFn()
var promiseB = promiseA.then(...)
var promiseC = promiseA.then(...)

Now if promiseB.cancel() triggers cancellation on promiseA then this cancellation
will propagate downward and cancel also promiseC (because it can not be derived
from a cancelled Promise) but we were only aiming at cancelling promiseB
not promiseC.

Here we have 2 separate chains promiseA -> promiseB and promiseA -> promiseC.
Another perspective is to view the operation as a tree with promiseA as root and
with 2 branches whose leafs are promiseB and promiseC. So cancelling one branch
should not affect the other branch (however cancelling the root or cancelling
the whole tree should propagate to the branches as well).

A possible solution is to maintain some ref. couning in promisA. Each time we chain
a then operation we increase the counter if promiseA and once the derived
promise is completed (whatever the outcome) we decrese the counter. If the counter
reaches 0 then we cancel promiseA since all operations that depend on it
have completed.

But ref. couting can have subtle issues. For example what if after promiseB and
and promiseC aer cancelled - cancelling promiseA in the way - we reattach another
then operation in some other part of the code ? And I dont mention here issues
related to race conditions due to async scheduling of chained operations which makes
maintaining the ref. counter error prone. Issues like this one
is a simple illustration. And I'd expect more subtle issues to manifest in real world
applications (I've myself experienced many of those issues when implementing redux-saga
and I couldn't get rid of them until I dropped async scheduling in sequenced
operations and made everything synchronous).

So it's clear how we should propagate cancellation up depends on the
situation. But the problem is precisely how do we infer this situation. A Promise,
once created, lacks the whole context in which it is itself composed with other
Promises to build a control flow. While we can maintain a reference to the parent
promise from which the current promise was derived. We can not know how this
parent promise is used elsewhere and all the other operations that has been or
will be derived from it.
So we can not simply implement a cancel method in the Promise prototype because
we do not have enough information to interpret the meaning of the cancellation.

Another solution is to extract out the cancellation capability into a first
class value. For example we can create some token and then pass it down
to all async operations that construct Promises. The creator of the token can
request the cancellation at any moment. The async operations that have
received the token can then be notified of the cancellation. This is the
solution that was planned to be implemented into the TC39 standard (but was
dropped because of lack of consensus).

We can view the token based solution as an indirect way to describe chained
steps as a whole unit. A created cancel token denote itself the whole operation
and all async functions that receive the token are part of the unit.

Another solution, which IMHO is simpler, more composable and ergonomic is to
make this whole operation - the big picture - itself as a first class value
using Tasks.

Tasks are lazy Promises

A Task can be thought of as a lazy Promise. For example, the following Promise

const promiseA = new Promise((resolve, reject) = {
  invokeAsyncFunc((err, res) => {
    if(err) reject(err)
    else resolve(res)
  })
})

Can be made lazy like this

const lazyPromiseA = () => new Promise((resolve, reject) = {
  invokeAsyncFunc((err, res) => {
    if(err) reject(err)
    else resolve(res)
  })
})

The difference is that in the first case the operation is started right after the
Promise creation. While in the second we've only constructed a description of t
he operation.

Now suppose we want to describe a new operation that is the chaining of the above
and another one

const lazySequence = () => lazyPromiseA().then(...)

So what's the difference ? one may ask.

Well in the case of normal/hot promises, we've seen that we can not interpret

var hotSequence = promiseA.then(...)

as a whole operation that includes promiseA because this one can be used
elsewhere in another sequence.

However in the case of lazy Promises we do have this knowledge. Precisely because
the operation has not started yet. And simply because we will start it ourselves
as a whole operation.

So Tasks are just this and nothing more. The Task
abstraction provided by this library or by
folktale's Data.Task
just wraps this lazy execution and makes it more composable by providing functions to
describe the control flow (like then/chain, all, race ...)

In avenir, you can create a Task with a API similar to Promises using
Task.from. Note the executor
argument takes also a cancel callback. This can be invoked by the executor to
trigger cancellation from the source.

const myTask = Task.from((resolve, reject, cancel) = {
  invokeAsyncFunc((err, res) => {
    if(err) reject(err)
    else resolve(res)
  })
})

The executor of the Task is not started at the Task creation. It means no side
effect takes place at this moment yet. To effectively start a Task, you must
invoke its run method

// Execution starts from here
myTask.run(onSuccess, onError, onCancel)

Tasks are Cancellable

After a Task has been started, it can be cancelled using the returned Future

// Execution starts from here
const future = myTask.run(onSuccess, onError, onCancel)

// ... after some time
future.cancel('some reason')

You can use Task#then
to chain another step

const myWholeTask = myTask.then(...)

myWholeTask is a new Task that describes the whole sequence. So when starting it

// Task#fork is the same as Task#run but does not take callbcaks
const future = myWholeTask.fork()

Cancelling the returned future will cancel the whole sequence. Due to their lazy
nature, Tasks give an unambiguous meaning to cancellation.

Tasks are Joinable

Sometimes a Task needs to join the result of an already started Task (ie a Future).
This can happen if, for example, the 2 Tasks are started from 2 unrelated
contexts (like 2 events handlers in separate UIs).

For example suppose we have a login Task that is started when the user clicks on
a UI button

const loginTask = Task.from((resolve, reject, cancel) => {
  api.authorize((err, ok) => {
    // attach a cancellation from the source
    onCancelLoginClick(() => cancel('Login cancelled'))
    if(err) reject(err)
    else resolve(ok)
  })
})


let loginFuture

function loginClickHandler() {
  loginFuture = loginTask.run(onSuccess, onReject, onCancel)
}

In another part of the UI, we want to start fetching something but only after the
login succeds. We can use Task.join
to wait for loginFuture to finish

// Task.do allows using Generator syntax
const fetchDataTask = Task.do(function*() {
  yield Task.join(loginFuture)
  const data = yield myFetchTask
  return data
})

Above, we used the Generator syntax to describe the operation. We wait for loginFuture
to resolve before continuing. If the login task was cancelled (either by invoking
loginFuture.cancel() or by the loginTask itself if the user clicks on a CancelLogin
button) then the fetchDataTask will be cancelled as well.

Observe that if we cancel fetchDataTask for some other reason while we're
still waiting for loginFuture

const future = fetchDataTask.fork()

// for some reason later
future.cancel('some reason')

Then this will only affect fetchDataTask and not loginTask. Cancelling the result
of Task.join(loginFuture) (which is itself a Task) will only unsubscribe from
the result of loginFuture. The loginTask stays unaffected.

Documentation

API Docs