Merge pull request scala/scala#10230 from som-snytt/tweak/isEmpty-knownSize

IterableOnce.isEmpty uses knownSize, sum is reduce

Author: lrytz

library/src/scala/collection/IterableOnce.scala

@@ -843,7 +843,12 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    *
    *  @return    `true` if the $coll contains no elements, `false` otherwise.
    */
-  def isEmpty: Boolean = !iterator.hasNext
+  def isEmpty: Boolean =
+    knownSize match {
+      case -1 => !iterator.hasNext
+      case  0 => true
+      case  _ => false
+    }
 
   /** Tests whether the $coll is not empty.
    *
@@ -929,7 +934,9 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
     i - start
   }
 
-  /** Sums up the elements of this collection.
+  /** Sums the elements of this collection.
+   *
+   *  The default implementation uses `reduce` for a known non-empty collection, `foldLeft` otherwise.
    *
    *   $willNotTerminateInf
    *
@@ -940,12 +947,14 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    */
   def sum[B >: A](implicit num: Numeric[B]): B =
     knownSize match {
-      case -1 => reduceLeftIterator[B](num.zero)(num.plus)
+      case -1 => foldLeft(num.zero)(num.plus)
       case  0 => num.zero
       case  _ => reduce(num.plus)
     }
 
-  /** Multiplies up the elements of this collection.
+  /** Multiplies together the elements of this collection.
+   *
+   *  The default implementation uses `reduce` for a known non-empty collection, `foldLeft` otherwise.
    *
    *  $willNotTerminateInf
    *
@@ -956,7 +965,7 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
    */
   def product[B >: A](implicit num: Numeric[B]): B =
     knownSize match {
-      case -1 => reduceLeftIterator[B](num.one)(num.times)
+      case -1 => foldLeft(num.one)(num.times)
       case  0 => num.one
       case  _ => reduce(num.times)
     }

library/src/scala/math/Numeric.scala

@@ -177,9 +177,20 @@ object Numeric {
   implicit object DoubleIsFractional extends DoubleIsFractional with Ordering.Double.IeeeOrdering
 
   trait BigDecimalIsConflicted extends Numeric[BigDecimal] {
-    def plus(x: BigDecimal, y: BigDecimal): BigDecimal = x + y
-    def minus(x: BigDecimal, y: BigDecimal): BigDecimal = x - y
-    def times(x: BigDecimal, y: BigDecimal): BigDecimal = x * y
+    // works around pollution of math context by ignoring identity element
+    def plus(x: BigDecimal, y: BigDecimal): BigDecimal = {
+      import BigDecimalIsConflicted._0
+      if (x eq _0) y else x + y
+    }
+    def minus(x: BigDecimal, y: BigDecimal): BigDecimal = {
+      import BigDecimalIsConflicted._0
+      if (x eq _0) -y else x - y
+    }
+    // works around pollution of math context by ignoring identity element
+    def times(x: BigDecimal, y: BigDecimal): BigDecimal = {
+      import BigDecimalIsConflicted._1
+      if (x eq _1) y else x * y
+    }
     def negate(x: BigDecimal): BigDecimal = -x
     def fromInt(x: Int): BigDecimal = BigDecimal(x)
     def parseString(str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
@@ -188,6 +199,10 @@ object Numeric {
     def toFloat(x: BigDecimal): Float = x.floatValue
     def toDouble(x: BigDecimal): Double = x.doubleValue
   }
+  private object BigDecimalIsConflicted {
+    private val _0 = BigDecimal(0)   // cached zero is ordinarily cached for default math context
+    private val _1 = BigDecimal(1)   // cached one is ordinarily cached for default math context
+  }
 
   trait BigDecimalIsFractional extends BigDecimalIsConflicted with Fractional[BigDecimal] {
     def div(x: BigDecimal, y: BigDecimal): BigDecimal = x / y