Async

A monad that can describe asynchronous or synchronous computations that produce exactly one result.

==On Asynchrony==

An asynchronous task represents logic that executes independent of the main program flow, or current callstack. It can be a task whose result gets computed on another thread, or on some other machine on the network.

In terms of types, normally asynchronous processes are represented as:

 (A => Unit) => Unit

This signature can be recognized in the "Observer pattern" described in the "Gang of Four", although it should be noted that without an onComplete event (like in the Rx Observable pattern) you can't detect completion in case this callback can be called zero or multiple times.

Some abstractions allow for signaling an error condition (e.g. MonadError data types), so this would be a signature that's closer to Scala's Future#onComplete:

 (Either[Throwable, A] => Unit) => Unit

And many times the abstractions built to deal with asynchronous tasks also provide a way to cancel such processes, to be used in race conditions in order to cleanup resources early:

 (A => Unit) => Cancelable

This is approximately the signature of JavaScript's setTimeout, which will return a "task ID" that can be used to cancel it.

N.B. this type class in particular is NOT describing cancelable async processes, see the Concurrent type class for that.

==Async Type class==

This type class allows the modeling of data types that:

1. can start asynchronous processes
2. can emit one result on completion
3. can end in error

N.B. on the "one result" signaling, this is not an ''exactly once'' requirement. At this point streaming types can implement Async and such an ''exactly once'' requirement is only clear in Effect.

Therefore the signature exposed by the async builder is this:

 (Either[Throwable, A] => Unit) => Unit

N.B. such asynchronous processes are not cancelable. See the Concurrent alternative for that.