anchor.diff:      // If the task fails, get the full list of exceptions (unlike Future.sequence)
   ----
   
  -Also, many, many convenience methods (e.g. Future.get, Future.toTry and Future.fold)
  +Also, many, many convenience and utility methods:
  +
  +* +A.future+ - Stop typing Future.successful(A)
  +* +Future.get+ - Await.result without all the typing
  +* +Future.flatten+ - Convert Future[Future[A]] into Future[A]
  +* +Future.toTry+ - Convert Future[A] to Future[Try[A]] that always succeeds
  +* +Future.fold+ - fold Future[A] Success[A]/Failure[A] to Future[B]
  +* +Collection.sequence+ - Future.sequence with less typing
  +* +Future.onTimeout+ - do something if a Future doesn't complete within a given amount of time
  +* +Future.happensBefore+ - start a Future after another Future completes
  +* +Future.sideEffect+ - do something after a Future completes. Don't change the return type but fail the Future if the
  +side effect fails
  +* +Future.delayed+ - start a Future after a delay
  +* +ScheduledExecutionContext.scheduleCancellable+ - start a Future after a delay that can be cancelled
  +* +ScheduledExecutionContext.scheduleAtFixed+ - create a repeating task
   
   == Overview
   +s_mach.concurrent+ is an open-source Scala library that provides asynchronous
  
positive.code: val future : Future[(Int,Double,String)] =
    async // start a new async task
      .par(2) // run 2 ops at a time
      .progress(1.second)(progress => println(progress)) // print progress
      .retry { // retry some errors with a random delay
        case _:TimeoutException =>
          Future.delayed(Random.nextInt(100).millis)(true)
  
negative.code: Create async tasks and configure them to:
  
  * Retry errors
  * Control the number of simultaneous operations
  * Limit the number of operations per second
  
  [source,scala,numbered]
  