code: @SuppressWarnings("unchecked")
    public <G, ERR, A, I extends Iterable<? extends G>> OrFuture<I, Every<ERR>>
    combined(Iterable<? extends OrFuture<? extends G, ? extends Every<? extends ERR>>> input,
             Collector<? super G, A, I> collector) {
      A goods = collector.supplier().get();
      BiFunction<OrFuture<Tuple0, Every<ERR>>, OrFuture<G, Every<ERR>>, OrFuture<Tuple0, Every<ERR>>> combiner =
          (ft0, fg) -> withGood(ft0, fg, (__,g) -> {
            collector.accumulator().accept(goods, g);
            return Tuple0.instance();
          });
  
      return Iterator
          .ofAll((Iterable<OrFuture<G, Every<ERR>>>) input)
          .foldLeft(this.goodFuture(null), combiner)
          .map(vec -> collector.finisher().apply(goods));
    }
docs: Combines an Iterable of OrFutures of type OrFuture&lt;G, EVERY&lt;ERR&gt;&gt; (where
  EVERY is some subtype of Every) into a single OrFuture of type
  OrFuture&lt;COLL&lt;G&gt;, Every&lt;ERR&gt;&gt; using a Collector to determine
  the wanted collection type COLL.
  <p>
  This method differs from sequence in that it will accumulate every error in the returned
  future before completing.
  
  @param <G>       the success type
  @param <A>       the mutable accumulation type of the reduction operation of the collector
  @param <ERR>     the failure type
  @param <I>       the resulting success iterable type
  @param input     the iterable containing OrFutures to combine
  @param collector the collector producing the resulting collection
  @return an OrFuture that completes with all the success values or with all the errors