Push BigDecimal exclusion into Numeric

Author: som-snytt

library/src/scala/collection/IterableOnce.scala

@@ -936,11 +936,7 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
 
   /** Sums the elements of this collection.
    *
-   *  The default implementation uses `reduce` for a known non-empty collection,
-   *  `foldLeft` otherwise.
-   *
-   *  If `foldLeft` is used, this implementation works around pollution of the math context
-   *  by ignoring the identity element.
+   *  The default implementation uses `reduce` for a known non-empty collection, `foldLeft` otherwise.
    *
    *   $willNotTerminateInf
    *
@@ -951,24 +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 =>
-        val z = num.zero
-        if ((num eq Numeric.BigDecimalIsFractional) || (num eq Numeric.BigDecimalAsIfIntegral)) {
-          def nonPollutingPlus(x: B, y: B): B = if (x.asInstanceOf[AnyRef] eq z.asInstanceOf[AnyRef]) y else num.plus(x, y)
-          foldLeft(z)(nonPollutingPlus)
-        }
-        else foldLeft(z)(num.plus)
+      case -1 => foldLeft(num.zero)(num.plus)
       case  0 => num.zero
       case  _ => reduce(num.plus)
     }
 
   /** Multiplies together the elements of this collection.
    *
-   *  The default implementation uses `reduce` for a known non-empty collection,
-   *  `foldLeft` otherwise.
-   *
-   *  If `foldLeft` is used, this implementation works around pollution of the math context
-   *  by ignoring the identity element.
+   *  The default implementation uses `reduce` for a known non-empty collection, `foldLeft` otherwise.
    *
    *  $willNotTerminateInf
    *
@@ -979,13 +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 =>
-        val u = num.one
-        if ((num eq Numeric.BigDecimalIsFractional) || (num eq Numeric.BigDecimalAsIfIntegral)) {
-          def nonPollutingProd(x: B, y: B): B = if (x.asInstanceOf[AnyRef] eq u.asInstanceOf[AnyRef]) y else num.times(x, y)
-          foldLeft(u)(nonPollutingProd)
-        }
-        else foldLeft(u)(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