Added marker trait to indicate when splits are efficient.

Author: Ichoran

src/main/scala/scala/compat/java8/StepConverters.scala

@@ -4,6 +4,7 @@ import language.implicitConversions
 
 import java.util.stream._
 import scala.compat.java8.collectionImpl._
+import scala.compat.java8.converterImpls._
 
 trait PrimitiveStreamAccumulator[S, AA] {
   def streamAccumulate(stream: S): AA
@@ -13,7 +14,7 @@ trait PrimitiveStreamUnboxer[A, S] {
   def apply(boxed: Stream[A]): S
 }
 
-trait Priority3StreamConverters {
+trait Priority6StreamConverters {
   implicit class EnrichAnyScalaCollectionWithStream[A](t: TraversableOnce[A]) {
     private def mkAcc() = {
       val acc = new Accumulator[A]
@@ -27,7 +28,7 @@ trait Priority3StreamConverters {
   }  
 }
 
-trait Priority2StreamConverters extends Priority3StreamConverters {
+trait Priority5StreamConverters extends Priority6StreamConverters {
   implicit class EnrichScalaCollectionWithStream[A <: AnyRef](t: TraversableOnce[A]) {
     private def mkArr()(implicit tag: reflect.ClassTag[A]): Array[A] = {
       if (t.isTraversableAgain && t.hasDefiniteSize) {
@@ -43,8 +44,21 @@ trait Priority2StreamConverters extends Priority3StreamConverters {
       java.util.Arrays.stream(mkArr())
 
     def parStream(implicit tag: reflect.ClassTag[A]): Stream[A] = seqStream.parallel
+  }  
+}
+
+trait Priority4StreamConverters extends Priority5StreamConverters {
+  implicit class EnrichAnySteppableWithStream[A, CC](cc: CC)(implicit steppize: CC => MakesAnyStepper[A]) {
+    def seqStream: Stream[A] = java.util.stream.StreamSupport.stream(steppize(cc).stepper, false)
+    def parStream: Stream[A] = java.util.stream.StreamSupport.stream(steppize(cc).stepper, true)
   }
+}
 
+trait Priority3StreamConverters extends Priority4StreamConverters {
+
+}
+
+trait Priority2StreamConverters extends Priority3StreamConverters {
   implicit class EnrichMissingPrimitiveArrayWithStream[A](a: Array[A]) {
     private def mkAcc() = {
       val acc = new Accumulator[A]

src/main/scala/scala/compat/java8/StreamConverters.scala

@@ -38,6 +38,12 @@ import java.util.Spliterator
   */
 trait Stepper[@specialized(Double, Int, Long) A] extends StepperLike[A, Stepper[A]] {}
 
+/** An (optional) marker trait that indicates that a `Stepper` can call `substep` with
+  * at worst O(log N) time and space complexity, and that the division is likely to
+  * be reasonably even.
+  */
+trait EfficientSubstep {}
+
 /** Provides functionality for Stepper while keeping track of a more precise type of the collection.
   */
 trait StepperLike[@specialized(Double, Int, Long) A, +CC] { self =>

src/main/scala/scala/compat/java8/collectionImpl/Stepper.scala

@@ -35,7 +35,8 @@ abstract class AbstractStepsLikeGapped[Sub >: Null, Semi <: Sub](protected val u
   */
 abstract class StepsLikeGapped[A, STA >: Null <: StepsLikeGapped[A, _]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[AnyStepper[A], STA](_underlying, _i0, _iN)
-  with AnyStepper[A] 
+  with AnyStepper[A]
+  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -44,7 +45,8 @@ abstract class StepsLikeGapped[A, STA >: Null <: StepsLikeGapped[A, _]](_underly
   */
 abstract class StepsDoubleLikeGapped[STD >: Null <: StepsDoubleLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[DoubleStepper, STD](_underlying, _i0, _iN)
-  with DoubleStepper 
+  with DoubleStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -53,7 +55,8 @@ abstract class StepsDoubleLikeGapped[STD >: Null <: StepsDoubleLikeGapped[_]](_u
   */
 abstract class StepsIntLikeGapped[STI >: Null <: StepsIntLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[IntStepper, STI](_underlying, _i0, _iN)
-  with IntStepper 
+  with IntStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -63,4 +66,5 @@ abstract class StepsIntLikeGapped[STI >: Null <: StepsIntLikeGapped[_]](_underly
 abstract class StepsLongLikeGapped[STL >: Null <: StepsLongLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[LongStepper, STL](_underlying, _i0, _iN)
   with LongStepper 
+  with EfficientSubstep
 {}

src/main/scala/scala/compat/java8/collectionImpl/StepsLikeGapped.scala

@@ -24,22 +24,26 @@ abstract class AbstractStepsLikeIndexed[Sub >: Null, Semi <: Sub](protected var
 abstract class StepsLikeIndexed[A, STA >: Null <: StepsLikeIndexed[A, _]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[AnyStepper[A], STA](_i0, _iN)
   with AnyStepper[A]
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Doubles */
 abstract class StepsDoubleLikeIndexed[STD >: Null <: StepsDoubleLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[DoubleStepper, STD](_i0, _iN)
   with DoubleStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Ints */
 abstract class StepsIntLikeIndexed[STI >: Null <: StepsIntLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[IntStepper, STI](_i0, _iN)
   with IntStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Longs */
 abstract class StepsLongLikeIndexed[STL >: Null <: StepsLongLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[LongStepper, STL](_i0, _iN)
   with LongStepper
+  with EfficientSubstep
 {}

src/main/scala/scala/compat/java8/collectionImpl/StepsLikeIndexed.scala

@@ -19,22 +19,26 @@ abstract class AbstractStepsLikeSliced[Coll, Sub >: Null, Semi <: Sub](protected
 abstract class StepsLikeSliced[A, AA, STA >: Null <: StepsLikeSliced[A, AA, _]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, AnyStepper[A], STA](_underlying, _i0, _iN)
   with AnyStepper[A]
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Doubles that can be efficiently sliced or otherwise subdivided */
 abstract class StepsDoubleLikeSliced[AA, STA >: Null <: StepsDoubleLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, DoubleStepper, STA](_underlying, _i0, _iN)
   with DoubleStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Ints that can be efficiently sliced or otherwise subdivided */
 abstract class StepsIntLikeSliced[AA, STA >: Null <: StepsIntLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, IntStepper, STA](_underlying, _i0, _iN)
   with IntStepper
+  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Longs that can be efficiently sliced or otherwise subdivided */
 abstract class StepsLongLikeSliced[AA, STA >: Null <: StepsLongLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, LongStepper, STA](_underlying, _i0, _iN)
   with LongStepper
+  with EfficientSubstep
 {}