Yet another run at reduce

[Brian Goetz]

OK, here's a longer on-ramp.

The basic form of groupBy is:
   <K> Map<K,Collection<T>> groupBy(Function<T,K> classifier)

Which we treat as a special case of the groupBy form that lets you 
provide factories for the result (a Map) and the per-key containers 
(Collection):

     groupBy(classifier, HashMap::new, ArrayList::new)

Which we treat as a special case of a cascaded reduce, where the 
downstream reducer creates and inserts into collections using the 
provided factories:

     Reducer<T, M> groupBy(Function<? super T, ? extends K> classifier,
                           Supplier<M> mapFactory,
                           Supplier<C> rowFactory) {
         return groupBy(classifier, mapFactory, intoCollection(rowFactory));
     }

Where intoCollection is a simple Reducer:

     Reducer<T,C> intoCollection(Supplier<C> collectionFactory) {
         return leftCombiningReducer(collectionFactory, Collection::add, 
Collection::addAll);
     }

Which we feed into the cascaded reduce that I posted in the last one.

I like to think of this in terms of the "marble maze" toys we played 
with as kids.  I had one with a cool "black box" where marbles would go 
in the top slot and would come out one of several holes at the bottom 
based on internal flip-flops.  The groupBy reducer is like one of those; 
think of that black box as the classifying function, and hook up each of 
the output holes to another downstream reducing box.  If you have enough 
boxes (and enough gravitational potential) you can keep cascading these. 
  Said boxes can do classification into Maps, partitioning, etc.  At the 
bottom, the simplest form of reducing box is an actual box which 
collects the marbles.  Which is what intoCollection() does.  (Marble 
mazes had both List and Set forms for collecting marbles too.)

On 1/8/2013 10:32 AM, Tim Peierls wrote:
> On Tue, Jan 8, 2013 at 10:15 AM, Brian Goetz <brian.goetz at oracle.com
> <mailto:brian.goetz at oracle.com>> wrote:
>
>     Here's a regular reducer that does a two-level groupBy with a
>     downstream reducer:
>
>
> Thanks. I was kind of hoping for a longer on-ramp, but I can (just
> barely) follow this. :-)
>
>     Or by examples, did you mean use examples?
>
>
> No, I wanted to see an impl.
>
> --tim