Collectors update

[Joe Bowbeer]

In Groovy, collect() is sometimes used like map() and sometimes like
toCollection().

I don't know why they didn't just call it map(), but oh well...

I would be upset if we wanted to use map() for something other than map()
but I'm not bothered by our use of collect().  In my view, collect() has no
standard meaning.  Inconsistencies cannot be avoided.


On Tue, Jan 29, 2013 at 3:49 PM, Raab, Donald <Donald.Raab at gs.com> wrote:

> Folks using GS Collections or Apache Commons can write the following:****
>
> ** **
>
> collection.collect(Thing::getFoo).stream().collect(groupingBy(Foo::getBar))
> ****
>
> CollectionUtils.collect(collection,
> Thing::getFoo).stream().collect(groupingBy(Foo::getBar))****
>
> ** **
>
> I’m not exactly sure how Groovy and Java 8 will mix syntax wise so can’t
> give an example.****
>
> ** **
>
> I would assume that no one would like to use the name “map” here, as it
> would be hard to teach map, because the name would be overloaded:****
>
> ** **
>
> collection.map(Thing::getFoo).stream().map(groupingBy(Foo::getBar))****
>
> ** **
>
> The method “map” has a meaning in languages/libraries outside of Streams
> and retains more or less the same meaning inside of Streams in our case.**
> **
>
> ** **
>
> In Smalltalk, Groovy, Ruby, Apache Commons Collections, GS Collections the
> method named “collect” is synonymous to “map” and “transform”.  That’s what
> I believe will make it hard to teach/use here.****
>
> ** **
>
> ** **
>
> *From:* Joe Bowbeer [mailto:joe.bowbeer at gmail.com]
> *Sent:* Tuesday, January 29, 2013 6:24 PM
> *To:* Raab, Donald [Tech]
> *Cc:* Brian Goetz; lambda-libs-spec-experts at openjdk.java.net; Motlin,
> Craig P. [Tech]
> *Subject:* Re: Collectors update****
>
> ** **
>
> I like the way collect() parses.  I think aggregate() is more descriptive
> but also less appealing.****
>
> ** **
>
> Given that collect() is a method of Stream, I don't think it will be
> particularly challenging to teach.****
>
> ** **
>
> I wouldn't object to aggregate() though.****
>
> ** **
>
> On Tue, Jan 29, 2013 at 2:55 PM, Raab, Donald <Donald.Raab at gs.com> wrote:*
> ***
>
> Having the method name "collect" is going to make it very hard to teach
> folks to use the streams API with GS Collections as it means something
> different than our "collect" method.  It may equally cause problems for
> folks using Groovy, Apache Commons Collections and JRuby as well.
>
>
> http://groovy.codehaus.org/groovy-jdk/java/util/Collection.html#collect(groovy.lang.Closure)
>
> http://commons.apache.org/collections/api-release/org/apache/commons/collections/CollectionUtils.html
>
> We've gone through the names accumulate, tabulate (not sure if there are
> others)...
>
> I know there is a dwindling list of good names, and I'll settle when there
> are none better, but this particular name has 30+ years of prior art in
> Smalltalk influenced circles.  It is one of the most commonly used methods
> in our library and these other languages/libraries.
>
> Again, I'd like to propose "aggregate" as an alternative.
>
> stream.aggregate(groupingBy(Foo::getBar))****
>
>
>
> > -----Original Message-----
> > From: lambda-libs-spec-experts-bounces at openjdk.java.net [mailto:lambda-
> > libs-spec-experts-bounces at openjdk.java.net] On Behalf Of Brian Goetz
> > Sent: Tuesday, January 29, 2013 5:35 PM
> > To: lambda-libs-spec-experts at openjdk.java.net
> > Subject: Collectors update
> >
> > I've done some refactoring in Collectors to address some issues,
> > including approachability issues that were raised by Kevin.  See if you
> > like them.
> >
> > 1.  Rename to more verby names.  We now have
> >    groupingBy
> >    groupingReduce
> >    joiningWith
> >    partitioningBy
> >
> > instead of groupBy/mappedTo/partition.  This is designed to make it
> > more clear what is going on when you read code like:
> >
> >    stream.collect(groupingBy(Foo::getBar))
> >
> > by making it clear that groupingBy is not an action but a way of
> > describing the desired collecting.
> >
> > 2.  Break groupBy into two groups, groupingBy and groupingReduce.
> > While the distinction is somewhat arbitrary since groupBy *is* a
> > reduce, it is now more consistent with the method naming on Stream.
> >
> > 3.  Rename mappedTo(T->U) to joiningWith.
> >
> > 4.  Rejigger Partition to return an array again, with an explicit
> > lambda (which will likely be an array ctor ref) to make the array.
> > Eliminated the silly Partition class.
> >
> > 5.  Add more tests -- we now have full test coverage on groupingXxx but
> > not yet the others.****
>
> ** **
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.openjdk.java.net/pipermail/lambda-libs-spec-experts/attachments/20130129/84212c2f/attachment-0001.html