code: public static <T, U> Collector<T, ?, Seq<T>> maxAllBy(Function<? super T, ? extends U> function, Comparator<? super U> comparator) {
          class Accumulator {
              List<T> t = new ArrayList<>();
              U u;
              void set(T t, U u) {
                  this.t.clear();
                  this.t.add(t);
                  this.u = u;
              }
          }
  
          return Collector.of(
              () -> new Accumulator(),
              (a, t) -> {
                  U u = function.apply(t);
                  if (a.u == null) {
                      a.set(t, u);
                  }
                  else {
                      int compare = comparator.compare(a.u, u);
  
                      if (compare < 0)
                          a.set(t, u);
                      else if (compare == 0)
                          a.t.add(t);
                  }
              },
              (a1, a2) -> {
                  if (a1.u == null)
                      return a2;
                  if (a2.u == null)
                      return a1;
  
                  int compare = comparator.compare(a1.u, a2.u);
  
                  if (compare < 0)
                      return a1;
                  else if (compare > 0)
                      return a2;
  
                  a1.t.addAll(a2.t);
                  return a1;
              },
              a -> Seq.seq(a.t)
          );
      }
docs: Get a {@link Collector} that calculates the <code>MAX()</code> function, producing multiple results.