code: public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate,
              Collector<? super T, A, D> downstream) {
          Predicate<A> finished = finished(downstream);
          if (finished != null) {
              BiConsumer<A, ? super T> accumulator = downstream.accumulator();
              return BooleanMap.partialCollector(downstream).asCancellable((map, t) -> accumulator.accept(predicate.test(
                  t) ? map.trueValue : map.falseValue, t), map -> finished.test(map.trueValue) && finished.test(
                      map.falseValue));
          }
          return Collectors.partitioningBy(predicate, downstream);
      }
docs: Returns a {@code Collector} which partitions the input elements according
  to a {@code Predicate}, reduces the values in each partition according to
  another {@code Collector}, and organizes them into a
  {@code Map<Boolean, D>} whose values are the result of the downstream
  reduction.
  
  <p>
  Unlike {@link Collectors#partitioningBy(Predicate, Collector)} this
  method returns a
  <a href="package-summary.html#ShortCircuitReduction">short-circuiting
  collector</a> if the downstream collector is short-circuiting.
  
  @param <T> the type of the input elements
  @param <A> the intermediate accumulation type of the downstream collector
  @param <D> the result type of the downstream reduction
  @param predicate a predicate used for classifying input elements
  @param downstream a {@code Collector} implementing the downstream
  reduction
  @return a {@code Collector} implementing the cascaded partitioning
  operation
  @since 0.4.0
  @see Collectors#partitioningBy(Predicate, Collector)