--- /dev/null	2013-02-14 00:07:37.184020992 -0500
+++ new/src/share/classes/java/util/stream/StatefulOp.java	2013-02-21 14:11:07.000000000 -0500
@@ -0,0 +1,44 @@
+package java.util.stream;
+
+/**
+ * A stateful intermediate stream operation ({@link IntermediateOp}).  <em>Stateful</em> means that state
+ * is accumulated as elements are processed.  Examples of stateful operations are sorting, extracting a subsequence
+ * of the input, or removing duplicates.  Statefulness has an effect on how the operation can be parallelized.
+ * Stateless operations parallelize trivially because they are homomorphisms under concatenation:
+ *
+ * <pre>
+ *     statelessOp(a || b) = statelessOp(a) || statelessOp(b)
+ * </pre>
+ *
+ * where {@code ||} denotes concatenation.  Stateful operations may still be parallelizable, but are not amenable to
+ * the automatic parallelization of stateless operations.  Accordingly, a stateful operation must provide its
+ * own parallel execution implementation ({@link #evaluateParallel(PipelineHelper)}).
+ *
+ * @param <E> Type of input and output elements.
+ *
+ * @see IntermediateOp
+ * @see TerminalOp
+ * @since 1.8
+ */
+interface StatefulOp<E> extends IntermediateOp<E, E> {
+
+    /**
+     * @{inheritDoc}
+     * This method must return {@code true}
+     * @implSpec The default implementations returns {@code true}
+     * @return {@code true}
+     */
+    @Override
+    public default boolean isStateful() {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * An implementation of this method must be provided, but it is acceptable if the implementation is sequential.
+     * A generic sequential implementation is available as
+     * {@link OpUtils#evaluateSequential(IntermediateOp, PipelineHelper)}.
+     */
+    <P_IN> Node<E> evaluateParallel(PipelineHelper<P_IN, E> helper);
+}