Merge pull request #1029 from japgolly/topic/reusabilityNum

More numeric Reusability

Author: japgolly

coreGeneric/src/main/scala/japgolly/scalajs/react/Reusability.scala

@@ -6,13 +6,15 @@ import japgolly.scalajs.react.util.Effect.Sync
 import japgolly.scalajs.react.util.{DefaultEffects, OptionLike}
 import java.time._
 import java.util.{Date, UUID}
+import java.{math => jm}
 import org.scalajs.dom.console
 import scala.annotation.tailrec
 import scala.collection.immutable.ArraySeq
 import scala.concurrent.{duration => scd}
 import scala.reflect.ClassTag
 import scala.scalajs.js.timers.{SetIntervalHandle, SetTimeoutHandle}
 import scala.scalajs.js.{Date => JsDate}
+import scala.{math => sm}
 
 /**
  * Tests whether one instance can be used in place of another.
@@ -141,6 +143,15 @@ object Reusability extends ReusabilityMacros with ScalaVersionSpecificReusabilit
   def float(tolerance: Float): Reusability[Float] =
     apply((x, y) => (x - y).abs <= tolerance)
 
+  def javaBigDecimal(tolerance: Double): Reusability[jm.BigDecimal] =
+    javaBigDecimal(new jm.BigDecimal(tolerance))
+
+  def javaBigDecimal(tolerance: jm.BigDecimal): Reusability[jm.BigDecimal] =
+    apply((x, y) => x.subtract(y).abs.compareTo(tolerance) <= 0)
+
+  def scalaBigDecimal(tolerance: sm.BigDecimal): Reusability[sm.BigDecimal] =
+    apply((x, y) => (x - y).abs.compareTo(tolerance) <= 0)
+
   def byJavaDuration[A](dur: (A, A) => Duration, tolerance: Duration): Reusability[A] =
     apply { (x, y) =>
       val d = dur(x, y).abs
@@ -284,6 +295,12 @@ object Reusability extends ReusabilityMacros with ScalaVersionSpecificReusabilit
   implicit lazy val setTimeoutHandle: Reusability[SetTimeoutHandle] =
     by_==
 
+  @inline implicit def bigInteger: Reusability[jm.BigInteger] =
+    byRefOr_==
+
+  @inline implicit def bigInt: Reusability[sm.BigInt] =
+    byRefOr_==
+
   // java.time._
 
   implicit def clock: Reusability[Clock] =
@@ -387,6 +404,13 @@ object Reusability extends ReusabilityMacros with ScalaVersionSpecificReusabilit
       Reusability.byRef || Reusability.map
   }
 
+  object DecimalImplicitsWithoutTolerance {
+    @inline implicit def reusabilityJavaBigDecimal : Reusability[jm.BigDecimal] = byRefOr_==
+    @inline implicit def reusabilityScalaBigDecimal: Reusability[sm.BigDecimal] = byRefOr_==
+    @inline implicit def reusabilityDouble         : Reusability[Double       ] = by_==
+    @inline implicit def reusabilityFloat          : Reusability[Float        ] = by_==
+  }
+
   object TemporalImplicitsWithoutTolerance {
 
     implicit lazy val reusabilityJavaDuration: Reusability[Duration] =

doc/changelog/2.0.1.md

@@ -1,5 +1,15 @@
 ## 2.0.1
 
+### New stuff
+
+* Added `Reusability` for:
+  * `java.math.BigDecimal`
+  * `java.math.BigInteger`
+  * `scala.math.BigDecimal`
+  * `scala.math.BigInt`
+
+* You can now `import Reusability.DecimalImplicitsWithoutTolerance._` if you'd like implicit `Reusability` instances for decimal types that use exact comparison
+
 ### Bug fixes
 
 * Fix infinite loop in functional components with reuse + `Reusability.never` ([#1027](https://github.com/japgolly/scalajs-react/issues/1027))

tests/src/test/scala/japgolly/scalajs/react/core/ReusabilityTest.scala

@@ -449,5 +449,33 @@ object ReusabilityTest extends TestSuite {
       assert(9.seconds ~/~ 7.seconds)
       assert(7.seconds ~/~ 9.seconds)
     }
+
+    "javaBigDecimal" - {
+      import java.math.BigDecimal
+      implicit val r = Reusability.javaBigDecimal(0.5)
+      assert(new BigDecimal(10.6) ~=~ new BigDecimal(10.6))
+      assert(new BigDecimal(10.6) ~=~ new BigDecimal(10.1))
+      assert(new BigDecimal(10.6) ~/~ new BigDecimal(10.0))
+    }
+
+    "scalaBigDecimal" - {
+      import scala.math.BigDecimal
+      implicit val r: Reusability[BigDecimal] = Reusability.scalaBigDecimal(0.5)
+      assert(BigDecimal(10.6) ~=~ BigDecimal(10.6))
+      assert(BigDecimal(10.6) ~=~ BigDecimal(10.1))
+      assert(BigDecimal(10.6) ~/~ BigDecimal(10.0))
+    }
+
+    "bigInteger" - {
+      import java.math.BigInteger
+      assert(new BigInteger("10") ~=~ new BigInteger("10"))
+      assert(new BigInteger("10") ~/~ new BigInteger("11"))
+    }
+
+    "bigInt" - {
+      import scala.math.BigInt
+      assert(BigInt("10") ~=~ BigInt("10"))
+      assert(BigInt("10") ~/~ BigInt("11"))
+    }
   }
 }