Scala equivalent of Java’s Number

by

Numeric[T] is exactly what you are looking for. Scala’s way to go here is type classes (i.e. a thing like Numeric).

Instead of

def foo(x: java.lang.Number) = x.doubleValue

write one of

def foo[T](x: T)(implicit n: Numeric[T]) = n.toDouble(x)
def foo[T : Numeric](x: T) = implicitly[Numeric[T]].toDouble(x)

where the second is (almost) nothing but syntactic sugar.

Numeric.Ops

Writing calls to the instance of Numeric every time you need an operation can become clumsy when the expression is more complex. To mitigate this, Numeric provides the implicit conversion mkNumericOps which augment T with the common ways of writing mathematical operations (i.e. 1 + 2 rather than n.plus(1,2)).

In order to use those, just import the members of the implicit Numeric:

def foo[T](x: T)(implicit n: Numeric[T]) = {
  import n._
  x.toDouble
}

Note that due to restrictions on import the abbreviated syntax for the implicit is hardly desirable here.

Type Classes

What happens here? If an argument list is marked as implicit, the compiler will automatically put a value of the required type there iff exactly one value of that type that is marked as implicit exists in scope. If you write

foo(1.0)

The compiler will automatically change this to

foo(1.0)(Numeric.DoubleIsFractional)

providing the method foo with operations on Double.

The huge advantage of this is that you can make types Numeric without them knowing. Suppose you have a library that gives you a type MyBigInt. Now suppose that in the Java world – unfortunately – the developers did not make it extend Number. There is nothing you can do.

In Scala, you can just write

implicit object MyBigIntIsNumeric extends Numeric[MyBigInt] {
   def compare(x: MyBigInt, y: MyBigInt) = ...
   // ...
}

and all your code using Numeric will now work with MyBigInt but you did not have to change the library. So Numeric could even be private to your project and this pattern would still work.

More Related Contents:

  1. How to convert scala List in to Map
  2. Best way to merge two maps and sum the values of same key?
  3. (Why) do we need to call cache or persist on a RDD
  4. Return in Scala
  5. How do I skip a header from CSV files in Spark?
  6. Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?
  7. Abort early in a fold
  8. Generating a class from string and instantiating it in Scala 2.10
  9. Append a column to Data Frame in Apache Spark 1.3
  10. Processing multiple files as independent RDD’s in parallel
  11. Spark: what’s the best strategy for joining a 2-tuple-key RDD with single-key RDD?
  12. How do I list all files in a subdirectory in scala?
  13. Why does the Scala compiler disallow overloaded methods with default arguments?
  14. withFilter instead of filter
  15. How to convert unix timestamp to date in Spark
  16. How to save a spark DataFrame as csv on disk?
  17. How to get ClassTag form TypeTag, or both at same time?
  18. `def` vs `val` vs `lazy val` evaluation in Scala
  19. How to process multi line input records in Spark
  20. How to sort by column in descending order in Spark SQL?
  21. Are HLists nothing more than a convoluted way of writing tuples?
  22. How to sort a list in Scala by two fields?
  23. Code to enumerate permutations in Scala
  24. Limits of Nat type in Shapeless
  25. Scalaz state monad examples
  26. Spark : how to run spark file from spark shell
  27. Using partial functions in Scala – how does it work?
  28. How do I run an sbt main class from the shell as normal command-line program?
  29. Singletons as Synthetic classes in Scala?
  30. Akka-Stream implementation slower than single threaded implementation

Leave a Comment