code: public StreamEx<List<T>> groupRuns(BiPredicate<? super T, ? super T> sameGroup) {
          return collapseInternal(sameGroup, Collections::singletonList, (acc, t) -> {
              if (!(acc instanceof ArrayList)) {
                  T old = acc.get(0);
                  acc = new ArrayList<>();
                  acc.add(old);
              }
              acc.add(t);
              return acc;
          }, (acc1, acc2) -> {
              if (!(acc1 instanceof ArrayList)) {
                  T old = acc1.get(0);
                  acc1 = new ArrayList<>();
                  acc1.add(old);
              }
              acc1.addAll(acc2);
              return acc1;
          });
      }
docs: Returns a stream consisting of lists of elements of this stream where
  adjacent elements are grouped according to supplied predicate.
  
  <p>
  This is a <a href="package-summary.html#StreamOps">quasi-intermediate</a>
  partial reduction operation.
  
  <p>
  There are no guarantees on the type, mutability, serializability, or
  thread-safety of the {@code List} objects of the resulting stream.
  
  <p>
  This operation is equivalent to
  {@code collapse(sameGroup, Collectors.toList())}, but more efficient.
  
  @param sameGroup a non-interfering, stateless predicate to apply to the
  pair of adjacent elements which returns true for elements which
  belong to the same group.
  @return the new stream
  @since 0.3.1