Why “avoid method overloading”?

by

Overloading makes it a little harder to lift a method to a function:

object A {
   def foo(a: Int) = 0
   def foo(b: Boolean) = 0
   def foo(a: Int, b: Int) = 0

   val function = foo _ // fails, must use = foo(_, _) or (a: Int) => foo(a)
}

You cannot selectively import one of a set of overloaded methods.

There is a greater chance that ambiguity will arise when trying to apply implicit views to adapt the arguments to the parameter types:

scala> implicit def S2B(s: String) = !s.isEmpty                             
S2B: (s: String)Boolean

scala> implicit def S2I(s: String) = s.length                               
S2I: (s: String)Int

scala> object test { def foo(a: Int) = 0; def foo(b: Boolean) = 1; foo("") }
<console>:15: error: ambiguous reference to overloaded definition,
both method foo in object test of type (b: Boolean)Int
and  method foo in object test of type (a: Int)Int
match argument types (java.lang.String)
       object test { def foo(a: Int) = 0; def foo(b: Boolean) = 1; foo("") }

It can quietly render default parameters unusable:

object test { 
    def foo(a: Int) = 0; 
    def foo(a: Int, b: Int = 0) = 1 
}

Individually, these reasons don’t compel you to completely shun overloading. I feel like I’m missing some bigger problems.

UPDATE

The evidence is stacking up.

UPDATE 2

  • You can’t (currently) use overloaded methods in package objects.
  • Applicability errors are harder to diagnose for callers of your API.

UPDATE 3

  • static overload resolution can rob an API of all type safety:
scala> object O { def apply[T](ts: T*) = (); def apply(f: (String => Int)) = () }
defined object O

scala> O((i: String) => f(i)) // oops, I meant to call the second overload but someone changed the return type of `f` when I wasn't looking...

More Related Contents:

  1. Why does the Scala compiler disallow overloaded methods with default arguments?
  2. Scala double definition (2 methods have the same type erasure)
  3. Overload constructor for Scala’s Case Classes?
  4. Apache Spark – Scala – ReduceByKey – with keys repeating up to twice only
  5. Spark – load CSV file as DataFrame?
  6. What is the difference between a var and val definition in Scala?
  7. What is a higher kinded type in Scala?
  8. What is the difference between “def” and “val” to define a function
  9. SparkSQL: How to deal with null values in user defined function?
  10. How to aggregate values into collection after groupBy?
  11. How to read records in JSON format from Kafka using Structured Streaming?
  12. Increase JVM heap size for Scala?
  13. How does Scala’s apply() method magic work?
  14. Instantiating immutable paired objects
  15. Why and how is Scala treating a tuple specially when calling a one arg function?
  16. Change nullable property of column in spark dataframe
  17. Scala pattern matching with lowercase variable name
  18. How to Define Custom partitioner for Spark RDDs of equally sized partition where each partition has equal number of elements?
  19. Can I get a compile-time list of all of the case objects which derive from a sealed parent in Scala?
  20. Scala “
  21. How does type Dynamic work and how to use it?
  22. Get a TypeTag from a Type?
  23. In Scala, what does “view” do?
  24. How to write a proper null-safe coalescing operator in scala?
  25. How to explode an array into multiple columns in Spark
  26. How can I convert immutable.Map to mutable.Map in Scala?
  27. Install sbt on ubuntu [closed]
  28. Should I use the final modifier when declaring case classes?
  29. Scala equivalent of Java’s Number
  30. Difference between two rows in Spark dataframe

Leave a Comment