Add Reusability for {java,scala}.math.Big*

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] =
@@ -388,8 +405,10 @@ object Reusability extends ReusabilityMacros with ScalaVersionSpecificReusabilit
   }
 
   object DecimalImplicitsWithoutTolerance {
-    @inline implicit def reusabilityDouble: Reusability[Double] = by_==
-    @inline implicit def reusabilityFloat : Reusability[Float ] = by_==
+    @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 {

doc/changelog/2.0.1.md

@@ -2,6 +2,12 @@
 
 ### 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

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"))
+    }
   }
 }