anchor.diff:  mean a significant amount of wasted time waiting on futures to complete whose results will be discarded. Also, while
   the scala parallel collections correctly handle multiple concurrent exceptions, +Future.sequence+ only returns the
   first exception encountered. In +Future.sequence+, all further exceptions past the first are discarded. The +merge+ and
  -+flatMerge+ methods fixes these problems by throwing +ConcurrentThrowable+. +ConcurrentThrowable+ has a member method to
  ++flatMerge+ methods fix 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 8: +Future.sequence+ gets stuck waiting on longRead to complete and only returns the first exception:
  
positive.code: 
  == Transforming and traversing collections using workers
  
  +s_mach.concurrent+ provides the +workers+ method allows specifying the maximum number of concurrent operations.
  
  .Example 3: Using +s_mach.concurrent+ workers to transform and traverse collections:
  [source,scala,numbered]
  
negative.code: }
  ----
  
  For concurrent operation, all of the futures must be started before the for-comprehension. The for-comprehension is a
  monadic workflow which captures commands that must take place in a specific sequential order. The pattern in example 2
  is necessary because Scala lacks an applicative workflow which captures commands that may be run in any order.
  +s_mach.concurrent+ adds the method +concurrently+ which is an applicative workflow specifically for futures. This
  method can more concisely express the pattern above:
  
  .Example 7: New +concurrently+ method
  [source,scala,numbered]
  