code: public static <G, A, ERR, I extends Iterable<? extends G>> Or<I, Every<ERR>>
    combined(Iterable<? extends Or<? extends G, ? extends Every<? extends ERR>>> input,
             Collector<? super G, A, I> collector) {
      A goods = collector.supplier().get();
      Vector<ERR> errs = Vector.empty();
      for (Or<? extends G, ? extends Every<? extends ERR>> or : input) {
        if (or.isGood()) collector.accumulator().accept(goods, or.get());
        else errs = errs.appendAll(or.getBad().toVector());
      }
      if (errs.isEmpty()) return Good.of(collector.finisher().apply(goods));
      else return Bad.of(Every.of(errs.head(), errs.tail()));
    }
docs: Combines an Iterable of Ors of type Or&lt;G, EVERY&lt;ERR&gt;&gt; (where
  EVERY is some subtype of Every) into a single Or of type
  Or&lt;COLL&lt;G&gt;, Every&lt;ERR&gt;&gt; using a Collector to determine
  the wanted collection type COLL.
  
  @param <G>       the success type of the resulting Or
  @param <A>       the mutable accumulation type of the reduction operation of the collector
  @param <ERR>     the failure type of the resulting Or
  @param <I>       the resulting success iterable type
  @param input     the iterable containing Ors to combine
  @param collector the collector producing the resulting collection
  @return an Or of all the success values or of all the errors