anchor.diff:  +s_mach.concurrent+ adds an applicative workflow method for futures: +concurrently+. This method can more concisely
   express the pattern above:
   
  -.Example 3: New +concurrently+ method
  +.Example 5: New +concurrently+ method
   [source,scala,numbered]
   ----
   for {
  
positive.code: +flatMerge+ methods fixes these problems by throwing +ConcurrentThrowable+. +ConcurrentThrowable+ has a member method to
  access both the first exception thrown and a future of all exceptions thrown during the computation.
  
  .Example 7: +Future.sequence+ gets stuck waiting on longRead to complete and only returns the first exception:
  [source,scala,numbered]
  ----
  scala> val t = Future.sequence(Vector(longRead("1"),readFail("2"),readFail("3"),read("4"))).getTry
  
negative.code: 
  scala> val allFailures = t.failed.get.asInstanceOf[ConcurrentThrowable].allFailure.get
  allFailures: Vector[Throwable] = Vector(java.lang.RuntimeException: 2, java.lang.RuntimeException: 3)
  ----
  
  == Retry and Throttle Control
  +s_mach.concurrent+ allows modifying collection concurrent operations to retry failures and limit iteration speed to a
  specific time setting.
  
  .Example 8: Adding retry and throttle Control to collection concurrent operations
  [source,scala,numbered]
  ----
  val oomItemIdBatch = (1 to 10).toList.map(_.toString).grouped(2).toList
  val future = { // necessary for pasting into repl
    for {
      oomItem <- {
        println("Reading...")
        oomItemIdBatch
          .workers(2)
          .throttle(100.millis) // limit to 1 batch per 100 milliseconds
          .flatMap { batch =>
            batch.
              .concurrently
              .retry { // retry certain exceptions
                case _: TimeoutException :: tail if tail.size < 3 => true
                case _: SocketTimeoutException :: _ if tail.size < 3 => true
                case _ => false
              }
              .throttle(1.millis) // limit to 1 id per 1 millisecond
              .map(read)
          }
      }
      _ = println("Computing...")
      oomNewItemBatch = oomItem.map(item => item.copy(value = item.value + 1)).grouped(10).toVector
      oomResult <- {
        println("Writing...")
        oomNewItemBatch.workers(2).flatMap(_.workers(4).map(item => write(item.id, item)))
      }
    } yield oomResult.forall(_ == true)
  }
  ----
  