code: public static <F, G, A, I extends Iterable<? extends G>, ERR>
    Or<I, Every<ERR>>
    validatedBy(Iterable<? extends F> iterable,
                Function<? super F, ? extends Or<? extends G, ? extends Every<? extends ERR>>> f,
                Collector<? super G, A, I> collector) {
  
      Vector<Or<? extends G, ? extends Every<? extends ERR>>> ors =
        Iterator
          .ofAll(iterable)
          .foldLeft(Vector.empty(), (vec, elem) -> vec.append(f.apply(elem)));
      return combined(ors, collector);
    }
docs: Maps an iterable of Fs into Ors of type Or&lt;G, EVERY&lt;ERR&gt;&gt;
  (where EVERY is some subtype of Every) using the passed function f, then
  combines the resulting Ors 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.
  <p>
  Note: the process implemented by this method is sometimes called a
  &quot;traverse&quot;.
  </p>
  
  @param <F>       the type of the original iterable to validate
  @param <G>       the Good type of the resulting Or
  @param <A>       the mutable accumulation type of the reduction operation of the collector
  @param <I>       the result type of the reduction operation
  @param <ERR>     the Bad type of the resulting Or
  @param iterable  the iterable to validate
  @param f         the validation function
  @param collector the collector producing the resulting collection
  @return an Or of all the success values or of all the errors