# HG changeset patch
# User briangoetz
# Date 1372449832 14400
# Node ID 67863c24056d63f121ff14c10c15f5d1743844a7
# Parent 7e974e3224d290232157f036725a6c0397b12108
[mq]: collector-hacks

diff -r 7e974e3224d2 src/share/classes/java/util/stream/Collectors.java
--- a/src/share/classes/java/util/stream/Collectors.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/src/share/classes/java/util/stream/Collectors.java	Tue Jul 09 14:25:40 2013 -0700
@@ -693,7 +693,7 @@
      */
     public static <T, K> Collector<T, ?, Map<K, List<T>>>
     groupingBy(Function<? super T, ? extends K> classifier) {
-        return groupingBy(classifier, toList());
+        return groupingBy(classifier, Collectors.<T>toList());
     }
 
     /**
@@ -839,7 +839,7 @@
     public static <T, K>
     Collector<T, ?, ConcurrentMap<K, List<T>>>
     groupingByConcurrent(Function<? super T, ? extends K> classifier) {
-        return groupingByConcurrent(classifier, ConcurrentHashMap::new, toList());
+        return groupingByConcurrent(classifier, ConcurrentHashMap::new, Collectors.<T>toList());
     }
 
     /**
@@ -982,7 +982,7 @@
      */
     public static <T>
     Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
-        return partitioningBy(predicate, toList());
+        return partitioningBy(predicate, Collectors.<T>toList());
     }
 
     /**
diff -r 7e974e3224d2 test/java/nio/file/Files/StreamTest.java
--- a/test/java/nio/file/Files/StreamTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/nio/file/Files/StreamTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -283,7 +283,7 @@
         PathBiPredicate pred = new PathBiPredicate((path, attrs) -> true);
 
         try (CloseableStream<Path> s = Files.find(testFolder, Integer.MAX_VALUE, pred)) {
-            Set<Path> result = s.collect(Collectors.toCollection(TreeSet::new));
+            Set<Path> result = s.collect(Collectors.<Path, TreeSet<Path>>toCollection(TreeSet::new));
             assertEquals(pred.visited(), all);
             assertEquals(result.toArray(new Path[0]), pred.visited());
         }
@@ -325,7 +325,7 @@
             byte[] hi = { (byte)'h', (byte)'i' };
             Files.write(tmpfile, hi);
             try (CloseableStream<String> s = Files.lines(tmpfile, US_ASCII)) {
-                List<String> lines = s.collect(Collectors.toList());
+                List<String> lines = s.collect(Collectors.<String>toList());
                 assertTrue(lines.size() == 1, "One line expected");
                 assertTrue(lines.get(0).equals("hi"), "'Hi' expected");
             }
@@ -335,7 +335,7 @@
             Files.write(tmpfile, expected, US_ASCII);
             assertTrue(Files.size(tmpfile) > 0, "File is empty");
             try (CloseableStream<String> s = Files.lines(tmpfile, US_ASCII)) {
-                List<String> lines = s.collect(Collectors.toList());
+                List<String> lines = s.collect(Collectors.<String>toList());
                 assertTrue(lines.equals(expected), "Unexpected lines");
             }
 
@@ -344,7 +344,7 @@
             Files.write(tmpfile, bad);
             try (CloseableStream<String> s = Files.lines(tmpfile, US_ASCII)) {
                 try {
-                    List<String> lines = s.collect(Collectors.toList());
+                    List<String> lines = s.collect(Collectors.<String>toList());
                     throw new RuntimeException("UncheckedIOException expected");
                 } catch (UncheckedIOException ex) {
                     assertTrue(ex.getCause() instanceof MalformedInputException,
diff -r 7e974e3224d2 test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java
--- a/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java	Tue Jul 09 14:25:40 2013 -0700
@@ -54,7 +54,7 @@
     STREAM_COLLECT(false) {
         <T, U, S_IN extends BaseStream<T, S_IN>>
         void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
-            for (U t : m.apply(data.stream()).collect(Collectors.toList())) {
+            for (U t : m.apply(data.stream()).collect(Collectors.<U>toList())) {
                 b.accept(t);
             }
         }
@@ -176,7 +176,7 @@
     PAR_STREAM_COLLECT(true) {
         <T, U, S_IN extends BaseStream<T, S_IN>>
         void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
-            for (U u : m.apply(data.parallelStream()).collect(Collectors.toList()))
+            for (U u : m.apply(data.parallelStream()).collect(Collectors.<U>toList()))
                 b.accept(u);
         }
     },
@@ -185,7 +185,7 @@
     STREAM_TO_PAR_STREAM_COLLECT(true) {
         <T, U, S_IN extends BaseStream<T, S_IN>>
         void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
-            for (U u : m.apply(data.stream().parallel()).collect(Collectors.toList()))
+            for (U u : m.apply(data.stream().parallel()).collect(Collectors.<U>toList()))
                 b.accept(u);
         }
     },
@@ -194,7 +194,7 @@
     PAR_STREAM_TO_STREAM_COLLECT(true) {
         <T, U, S_IN extends BaseStream<T, S_IN>>
         void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
-            for (U u : m.apply(data.parallelStream().sequential()).collect(Collectors.toList()))
+            for (U u : m.apply(data.parallelStream().sequential()).collect(Collectors.<U>toList()))
                 b.accept(u);
         }
     },
diff -r 7e974e3224d2 test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java
--- a/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -71,7 +71,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(toList());
+                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList());
 
                 SpliteratorTestHelper.testSpliterator(() -> {
                     Spliterator<Integer> s = Arrays.spliterator(source.stream().toArray(Integer[]::new));
@@ -84,7 +84,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(toList());
+                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList());
 
                 SpliteratorTestHelper.testIntSpliterator(() -> {
                     Spliterator.OfInt s = Arrays.spliterator(source.stream().mapToInt(i->i).toArray());
@@ -97,7 +97,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Long> source =  LongStream.range(0, size).boxed().collect(toList());
+                final Collection<Long> source =  LongStream.range(0, size).boxed().collect(Collectors.<Long>toList());
 
                 SpliteratorTestHelper.testLongSpliterator(() -> {
                     Spliterator.OfLong s = Arrays.spliterator(source.stream().mapToLong(i->i).toArray());
@@ -110,7 +110,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Double> source =  LongStream.range(0, size).asDoubleStream().boxed().collect(toList());
+                final Collection<Double> source =  LongStream.range(0, size).asDoubleStream().boxed().collect(Collectors.<Double>toList());
 
                 SpliteratorTestHelper.testDoubleSpliterator(() -> {
                     Spliterator.OfDouble s = Arrays.spliterator(source.stream().mapToDouble(i->i).toArray());
@@ -126,7 +126,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(toList());
+                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList());
                 final UnorderedContentAsserter<Integer> uca = new UnorderedContentAsserter<>(source);
 
                 SpliteratorTestHelper.testSpliterator(() -> {
@@ -140,7 +140,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(toList());
+                final Collection<Integer> source =  IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList());
                 final UnorderedContentAsserter<Integer> uca = new UnorderedContentAsserter<>(source);
 
                 SpliteratorTestHelper.testIntSpliterator(() -> {
@@ -154,7 +154,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Long> source =  LongStream.range(0, size).boxed().collect(toList());
+                final Collection<Long> source =  LongStream.range(0, size).boxed().collect(Collectors.<Long>toList());
                 final UnorderedContentAsserter<Long> uca = new UnorderedContentAsserter<>(source);
 
                 SpliteratorTestHelper.testLongSpliterator(() -> {
@@ -168,7 +168,7 @@
 
         {
             SliceTester r = (size, skip, limit) -> {
-                final Collection<Double> source =  LongStream.range(0, size).asDoubleStream().boxed().collect(toList());
+                final Collection<Double> source =  LongStream.range(0, size).asDoubleStream().boxed().collect(Collectors.<Double>toList());
                 final UnorderedContentAsserter<Double> uca = new UnorderedContentAsserter<>(source);
 
                 SpliteratorTestHelper.testDoubleSpliterator(() -> {
diff -r 7e974e3224d2 test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java
--- a/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -46,7 +46,7 @@
                              .filter(i -> i >= 0)
                              .boxed()
                              .distinct()
-                             .collect(Collectors.toList());
+                             .collect(Collectors.<Integer>toList());
         }
         catch (Exception e) {
             e.printStackTrace();
@@ -110,7 +110,7 @@
         List<Integer> end = Arrays.stream(array)
                 .boxed()
                 .substream(array.length - lastSplitSize)
-                .collect(Collectors.toList());
+                .collect(Collectors.<Integer>toList());
         assertEquals(contentOfLastSplit, end);
     }
 
@@ -185,7 +185,7 @@
         List<Integer> end = Arrays.stream(array)
                 .boxed()
                 .substream(array.length - lastSplitSize)
-                .collect(Collectors.toList());
+                .collect(Collectors.<Integer>toList());
         assertEquals(contentOfLastSplit, end);
     }
 
@@ -260,7 +260,7 @@
         List<Long> end = Arrays.stream(array)
                 .boxed()
                 .substream(array.length - lastSplitSize)
-                .collect(Collectors.toList());
+                .collect(Collectors.<Long>toList());
         assertEquals(contentOfLastSplit, end);
     }
 
@@ -336,7 +336,7 @@
         List<Double> end = Arrays.stream(array)
                 .boxed()
                 .substream(array.length - lastSplitSize)
-                .collect(Collectors.toList());
+                .collect(Collectors.<Double>toList());
         assertEquals(contentOfLastSplit, end);
     }
 
diff -r 7e974e3224d2 test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java
--- a/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -116,7 +116,7 @@
 
     public void testPairSet() {
         List<Integer> sourceFlagsList
-                = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList());
+                = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(Collectors.<Integer>toList());
         sourceFlagsList.add(0, 0);
 
         for (int sourceFlags : sourceFlagsList) {
@@ -135,7 +135,7 @@
 
     public void testPairSetAndClear() {
         List<Integer> sourceFlagsList
-                = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList());
+                = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(Collectors.<Integer>toList());
         sourceFlagsList.add(0, 0);
 
         for (int sourceFlags : sourceFlagsList) {
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -81,7 +81,7 @@
     }
 
     public void testGroupBy() {
-        Map<Boolean,List<Integer>> result = countTo(10).stream().collect(Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
+        Map<Boolean,List<Integer>> result = countTo(10).stream().collect(Collectors.<Integer, Boolean>groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
 
         assertEquals(2, result.keySet().size());
         for(Collection<Integer> group : result.values()) {
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java	Tue Jul 09 14:25:40 2013 -0700
@@ -75,7 +75,7 @@
     }
 
     public void testBox() {
-        List<Integer> l = IntStream.range(1, 10).parallel().boxed().collect(Collectors.toList());
+        List<Integer> l = IntStream.range(1, 10).parallel().boxed().collect(Collectors.<Integer>toList());
         int sum = l.stream().reduce(0, (a, b) -> a + b);
         assertEquals(sum, 45);
     }
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java	Tue Jul 09 14:25:40 2013 -0700
@@ -75,7 +75,7 @@
     }
 
     public void testBox() {
-        List<Long> l = LongStream.range(1, 10).parallel().boxed().collect(Collectors.toList());
+        List<Long> l = LongStream.range(1, 10).parallel().boxed().collect(Collectors.<Long>toList());
         long sum = l.stream().reduce(0L, (a, b) -> a + b);
         assertEquals(sum, 45);
     }
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -23,6 +23,9 @@
 package org.openjdk.tests.java.util.stream;
 
 import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
 import java.util.stream.LambdaTestHelpers;
 import java.util.stream.OpTestCase;
 import java.util.stream.Stream;
@@ -47,8 +50,11 @@
 
     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOps(String name, TestData.OfRef<Integer> data) {
-        Map<Boolean,List<Integer>> gbResult = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
-        Map<Boolean, Integer> result = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false), reducing(0, rPlus)));
+        Map<Boolean,List<Integer>> gbResult = data.stream().collect(Collectors.<Integer, Boolean>groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
+        Collector<Integer,?,Integer> reducing = reducing(0, rPlus);
+        Function<Integer, Boolean> classifier = LambdaTestHelpers.forPredicate(pEven, true, false);
+        Collector<Integer, ?, Map<Boolean, Integer>> collector = groupingBy(classifier, reducing);
+        Map<Boolean, Integer> result = data.stream().collect(collector);
         assertEquals(result.size(), gbResult.size());
         for (Map.Entry<Boolean, Integer> entry : result.entrySet()) {
             setContext("entry", entry);
@@ -57,8 +63,12 @@
         }
 
         int uniqueSize = data.into(new HashSet<Integer>()).size();
-        Map<Integer, List<Integer>> mgResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId)));
-        Map<Integer, Integer> miResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId, reducing(0, e -> 1, Integer::sum))));
+        Map<Integer, List<Integer>> mgResult = exerciseTerminalOps(data, s -> s.collect(Collectors.<Integer, Integer>groupingBy(mId)));
+        Map<Integer, Integer> miResult = exerciseTerminalOps(data, s -> {
+            Collector<Integer, ?, Integer> reducing1 = reducing(0, e -> 1, Integer::sum);
+            Collector<Integer, ?, Map<Integer, Integer>> collector1 = groupingBy(mId, reducing1);
+            return s.collect(collector1);
+        });
         assertEquals(miResult.keySet().size(), uniqueSize);
         for (Map.Entry<Integer, Integer> entry : miResult.entrySet()) {
             setContext("entry", entry);
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -234,7 +234,7 @@
                 return s.getComparator();
             }
         }
-        List<Integer> list = IntStream.range(0, 100).boxed().collect(Collectors.toList());
+        List<Integer> list = IntStream.range(0, 100).boxed().collect(Collectors.<Integer>toList());
         TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(
                 "Non splitting, not SUBSIZED, ORDERED, stream",
                 () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator())));
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -29,6 +29,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.DoubleStream;
 import java.util.stream.IntStream;
 import java.util.stream.LambdaTestHelpers;
@@ -122,12 +123,12 @@
 
         withData(data).
                 stream(s -> s).
-                expectedResult(IntStream.range(0, size).boxed().collect(toList())).
+                expectedResult(IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList())).
                 exercise();
 
         withData(data).
                 stream(s -> s.map(LambdaTestHelpers.identity())).
-                expectedResult(IntStream.range(0, size).boxed().collect(toList())).
+                expectedResult(IntStream.range(0, size).boxed().collect(Collectors.<Integer>toList())).
                 exercise();
     }
 
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -48,7 +48,7 @@
     public void testManyStreams(String name, TestData.OfRef<Integer> data) {
         for (int n : sizes) {
             setContext("n", n);
-            List<Integer> expected = data.stream().map(e -> (Integer) (e + n)).collect(Collectors.toList());
+            List<Integer> expected = data.stream().map(e -> (Integer) (e + n)).collect(Collectors.<Integer>toList());
 
             withData(data).
                     stream(apply(n, (Stream<Integer> s) -> s.map(e -> (Integer) (e + 1)))).
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -43,9 +43,9 @@
 public class SummaryStatisticsTest extends OpTestCase {
     public void testIntStatistics() {
         List<IntSummaryStatistics> instances = new ArrayList<>();
-        instances.add(countTo(1000).stream().collect(Collectors.summarizingInt(i -> i)));
+        instances.add(countTo(1000).stream().collect(Collectors.<Integer>summarizingInt(i -> i)));
         instances.add(countTo(1000).stream().mapToInt(i -> i).summaryStatistics());
-        instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingInt(i -> i)));
+        instances.add(countTo(1000).parallelStream().collect(Collectors.<Integer>summarizingInt(i -> i)));
         instances.add(countTo(1000).parallelStream().mapToInt(i -> i).summaryStatistics());
 
         for (IntSummaryStatistics stats : instances) {
@@ -58,9 +58,9 @@
 
     public void testLongStatistics() {
         List<LongSummaryStatistics> instances = new ArrayList<>();
-        instances.add(countTo(1000).stream().collect(Collectors.summarizingLong(i -> i)));
+        instances.add(countTo(1000).stream().collect(Collectors.<Integer>summarizingLong(i -> i)));
         instances.add(countTo(1000).stream().mapToLong(i -> i).summaryStatistics());
-        instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingLong(i -> i)));
+        instances.add(countTo(1000).parallelStream().collect(Collectors.<Integer>summarizingLong(i -> i)));
         instances.add(countTo(1000).parallelStream().mapToLong(i -> i).summaryStatistics());
 
         for (LongSummaryStatistics stats : instances) {
@@ -73,9 +73,9 @@
 
     public void testDoubleStatistics() {
         List<DoubleSummaryStatistics> instances = new ArrayList<>();
-        instances.add(countTo(1000).stream().collect(Collectors.summarizingDouble(i -> i)));
+        instances.add(countTo(1000).stream().collect(Collectors.<Integer>summarizingDouble(i -> i)));
         instances.add(countTo(1000).stream().mapToDouble(i -> i).summaryStatistics());
-        instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingDouble(i -> i)));
+        instances.add(countTo(1000).parallelStream().collect(Collectors.<Integer>summarizingDouble(i -> i)));
         instances.add(countTo(1000).parallelStream().mapToDouble(i -> i).summaryStatistics());
 
         for (DoubleSummaryStatistics stats : instances) {
diff -r 7e974e3224d2 test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java	Fri Jun 28 16:26:54 2013 -0400
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java	Tue Jul 09 14:25:40 2013 -0700
@@ -36,6 +36,7 @@
 import java.util.StringJoiner;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -98,7 +99,7 @@
                          boolean ordered) throws ReflectiveOperationException {
             if (!clazz.isAssignableFrom(map.getClass()))
                 fail(String.format("Class mismatch in GroupedMapAssertion: %s, %s", clazz, map.getClass()));
-            assertContentsUnordered(map.keySet(), source.get().map(classifier).collect(toSet()));
+            assertContentsUnordered(map.keySet(), source.get().map(classifier).collect(Collectors.<K>toSet()));
             for (Map.Entry<K, ? extends V> entry : map.entrySet()) {
                 K key = entry.getKey();
                 downstream.assertValue(entry.getValue(),
@@ -126,7 +127,7 @@
 
         @Override
         void assertValue(M map, Supplier<Stream<T>> source, boolean ordered) throws ReflectiveOperationException {
-            Set<K> uniqueKeys = source.get().map(keyFn).collect(toSet());
+            Set<K> uniqueKeys = source.get().map(keyFn).collect(Collectors.<K>toSet());
             assertTrue(clazz.isAssignableFrom(map.getClass()));
             assertEquals(uniqueKeys, map.keySet());
             source.get().forEach(t -> {
@@ -458,12 +459,12 @@
 
         // With explicit constructors
         exerciseMapTabulation(data,
-                              groupingBy(classifier, TreeMap::new, toCollection(HashSet::new)),
+                              groupingBy(classifier, TreeMap::new, Collectors.<Integer, HashSet<Integer>>toCollection(HashSet::new)),
                               new GroupedMapAssertion<>(classifier, TreeMap.class,
                                                         new CollectionAssertion<Integer>(HashSet.class, false)));
+        Collector<Integer, ?, HashSet<Integer>> downstream = Collectors.<Integer, HashSet<Integer>>toCollection(HashSet::new);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new,
-                                                   toCollection(HashSet::new)),
+                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, downstream),
                               new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
                                                         new CollectionAssertion<Integer>(HashSet.class, false)));
     }
@@ -474,51 +475,58 @@
         Function<Integer, Integer> classifier2 = i -> i % 23;
 
         // Two-level groupBy
+        Collector<Integer, ?, Map<Integer, List<Integer>>> downstream = groupingBy(classifier2);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, groupingBy(classifier2)),
+                              groupingBy(classifier, downstream),
                               new GroupedMapAssertion<>(classifier, HashMap.class,
                                                         new GroupedMapAssertion<>(classifier2, HashMap.class,
                                                                                   new ListAssertion<>())));
         // with concurrent as upstream
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, groupingBy(classifier2)),
+                              groupingByConcurrent(classifier, downstream),
                               new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
                                                         new GroupedMapAssertion<>(classifier2, HashMap.class,
                                                                                   new ListAssertion<>())));
         // with concurrent as downstream
+        Collector<Integer, ?,ConcurrentMap<Integer,List<Integer>>> downstream1 = groupingByConcurrent(classifier2);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, groupingByConcurrent(classifier2)),
+                              groupingBy(classifier, downstream1),
                               new GroupedMapAssertion<>(classifier, HashMap.class,
                                                         new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class,
                                                                                   new ListAssertion<>())));
         // with concurrent as upstream and downstream
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, groupingByConcurrent(classifier2)),
+                              groupingByConcurrent(classifier, downstream1),
                               new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
                                                         new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class,
                                                                                   new ListAssertion<>())));
 
         // With explicit constructors
+        Collector<Integer, ?, HashSet<Integer>> downstream2 = Collectors.<Integer, HashSet<Integer>>toCollection(HashSet::new);
+        Collector<Integer, ?, TreeMap<Integer, HashSet<Integer>>> downstream3 = groupingBy(classifier2, TreeMap::new, downstream2);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, TreeMap::new, groupingBy(classifier2, TreeMap::new, toCollection(HashSet::new))),
+                              groupingBy(classifier, TreeMap::new, downstream3),
                               new GroupedMapAssertion<>(classifier, TreeMap.class,
                                                         new GroupedMapAssertion<>(classifier2, TreeMap.class,
                                                                                   new CollectionAssertion<Integer>(HashSet.class, false))));
         // with concurrent as upstream
+        Collector<Integer, ?, List<Integer>> toList = Collectors.<Integer>toList();
+        Collector<Integer, ?, TreeMap<Integer, List<Integer>>> downstream4 = groupingBy(classifier2, TreeMap::new, toList);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingBy(classifier2, TreeMap::new, toList())),
+                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, downstream4),
                               new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
                                                         new GroupedMapAssertion<>(classifier2, TreeMap.class,
                                                                                   new ListAssertion<>())));
         // with concurrent as downstream
+        Collector<Integer, ?, ConcurrentSkipListMap<Integer, List<Integer>>> downstream5 = groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, TreeMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())),
+                              groupingBy(classifier, TreeMap::new, downstream5),
                               new GroupedMapAssertion<>(classifier, TreeMap.class,
                                                         new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class,
                                                                                   new ListAssertion<>())));
         // with concurrent as upstream and downstream
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())),
+                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, downstream5),
                               new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
                                                         new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class,
                                                                                   new ListAssertion<>())));
@@ -529,46 +537,56 @@
         Function<Integer, Integer> classifier = i -> i % 3;
 
         // Single-level simple reduce
+        Collector<Integer, ?, Integer> reducing = reducing(0, Integer::sum);
+        Collector<Integer, ?, Map<Integer, Integer>> collector = groupingBy(classifier, reducing);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, reducing(0, Integer::sum)),
+                              collector,
                               new GroupedMapAssertion<>(classifier, HashMap.class,
                                                         new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
         // with concurrent
+        Collector<Integer, ?, ConcurrentMap<Integer, Integer>> collector1 = groupingByConcurrent(classifier, reducing);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, reducing(0, Integer::sum)),
+                              collector1,
                               new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
                                                         new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
 
         // With explicit constructors
+        Collector<Integer, ?, Map<Integer, Integer>> collector2 = groupingBy(classifier, TreeMap::new, reducing);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, TreeMap::new, reducing(0, Integer::sum)),
+                              collector2,
                               new GroupedMapAssertion<>(classifier, TreeMap.class,
                                                         new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
         // with concurrent
+        Collector<Integer, ?, ConcurrentSkipListMap<Integer, Integer>> collector3 = groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, Integer::sum)),
+                              collector3,
                               new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
                                                         new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
 
         // Single-level map-reduce
+        Collector<Integer, ?, Integer> reducing1 = reducing(0, mDoubler, Integer::sum);
+        Collector<Integer, ?, Map<Integer, Integer>> collector4 = groupingBy(classifier, reducing1);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, reducing(0, mDoubler, Integer::sum)),
+                              collector4,
                               new GroupedMapAssertion<>(classifier, HashMap.class,
                                                         new ReduceAssertion<>(0, mDoubler, Integer::sum)));
         // with concurrent
+        Collector<Integer, ?, ConcurrentMap<Integer, Integer>> collector5 = groupingByConcurrent(classifier, reducing1);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, reducing(0, mDoubler, Integer::sum)),
+                              collector5,
                               new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
                                                         new ReduceAssertion<>(0, mDoubler, Integer::sum)));
 
         // With explicit constructors
+        Collector<Integer, ?, Map<Integer, Integer>> collector6 = groupingBy(classifier, TreeMap::new, reducing1);
         exerciseMapTabulation(data,
-                              groupingBy(classifier, TreeMap::new, reducing(0, mDoubler, Integer::sum)),
+                              collector6,
                               new GroupedMapAssertion<>(classifier, TreeMap.class,
                                                         new ReduceAssertion<>(0, mDoubler, Integer::sum)));
         // with concurrent
+        Collector<Integer, ?, ConcurrentMap<Integer, Integer>> collector7 = groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing1);
         exerciseMapTabulation(data,
-                              groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, mDoubler, Integer::sum)),
+                              collector7,
                               new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
                                                         new ReduceAssertion<>(0, mDoubler, Integer::sum)));
     }
@@ -582,7 +600,7 @@
                               partitioningBy(classifier),
                               new PartitionAssertion<>(classifier, new ListAssertion<>()));
         exerciseMapTabulation(data,
-                              partitioningBy(classifier, toList()),
+                              partitioningBy(classifier, Collectors.<Integer>toList()),
                               new PartitionAssertion<>(classifier, new ListAssertion<>()));
     }
 
@@ -592,14 +610,16 @@
         Predicate<Integer> classifier2 = i -> i % 7 == 0;
 
         // Two level partition
+        Collector<Integer, ?, Map<Boolean, List<Integer>>> downstream = partitioningBy(classifier2);
         exerciseMapTabulation(data,
-                              partitioningBy(classifier, partitioningBy(classifier2)),
+                              partitioningBy(classifier, downstream),
                               new PartitionAssertion<>(classifier,
                                                        new PartitionAssertion(classifier2, new ListAssertion<>())));
 
         // Two level partition with reduce
+        Collector<Integer, ?, Integer> reducing = reducing(0, Integer::sum);
         exerciseMapTabulation(data,
-                              partitioningBy(classifier, reducing(0, Integer::sum)),
+                              partitioningBy(classifier, reducing),
                               new PartitionAssertion<>(classifier,
                                                        new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
     }