code: @NotNull
      public static <T, R> Collector<T, ?, R> reducing(
              @Nullable  final R identity,
              @NotNull final Function<? super T, ? extends R> mapper,
              @NotNull final BinaryOperator<R> op) {
          return new CollectorsImpl<T, Tuple1<R>, R>(
  
                  new Supplier<Tuple1<R>>() {
                      @NotNull
                      @Override
                      public Tuple1<R> get() {
                          return new Tuple1<R>(identity);
                      }
                  },
  
                  new BiConsumer<Tuple1<R>, T>() {
                      @Override
                      public void accept(@NotNull Tuple1<R> tuple, T value) {
                          tuple.a = op.apply(tuple.a, mapper.apply(value));
                      }
                  },
  
                  new Function<Tuple1<R>, R>() {
                      @Override
                      public R apply(@NotNull Tuple1<R> tuple) {
                          return tuple.a;
                      }
                  }
          );
      }
docs: Returns a {@code Collector} that reduces input elements.
  
  @param <T> the type of the input elements
  @param <R> the type of the output elements
  @param identity  the initial value
  @param mapper  the mapping function
  @param op  the operator to reduce elements
  @return a {@code Collector}
  @see #reducing(java.lang.Object, com.annimon.stream.function.BinaryOperator)