code: public static <T, R> Future<R> accumulate(final Iterable<Future<T>> fts, final Function<? super T, R> mapper, final Monoid<R> reducer) {
          return sequence(fts).map(s -> s.map(mapper)
                                         .reduce(reducer)
                                         );
      }
docs: Asynchronously accumulate the results of a batch of Futures which using the supplied mapping function to
  convert the data from each Future before reducing them using the supplied supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two
  input values of the same type and returns the combined result) {@see cyclops2.Monoids }.
  A single Failure results in a Failed  Future.
  
  <pre>
  {@code
  Future<String> future = Future.accumulate(Seq.of(Future.ofResult(10),Future.ofResult(1)),i->""+i,Monoids.stringConcat);
  Future["101"]
  }
  </pre>
  
  @param fts Collection of Futures to accumulate successes
  @param mapper Mapping function to be applied to the result of each Future
  @param reducer Monoid to combine values from each Future
  @return Future asynchronously populated with the accumulate operation