1. Overview

In this tutorial, we’ll learn about the Magnet Pattern in Scala. We’ll learn the benefits of using this pattern using some simple examples and use cases. Also, we’ll see some of the drawbacks and learn when to avoid using them.

2. What Is Magnet Pattern?

Magnet pattern is an advanced type-based pattern to deal with problems related to method overloading in Scala. A magnet pattern is a special case of the type-class pattern in which the target methods are invoked based on the types of parameters. Magnet pattern provides a more type-safe alternative for method overloading.

3. Type-Erasure and Benefits of Using Magnet Pattern

Method overloading is a very useful feature in Scala but does not work in all cases. It can fail due to method signature collisions caused by type-erasure in the JVM.

Let’s assume we’re writing a function that combines the elements in a list and returns the result based on the type of elements in the list. Based on the type of elements in the list, the combination logic varies. Typically, we write overloaded functions to handle such scenarios:

def combineElements(stringList:List[String]):String = stringList.mkString
def combineElements(charList: List[Char]):String = charList.mkString

If we try to define overloaded methods for List[String] and List[Int], we’ll receive an error message from the compiler telling us:

def combineElements .. have same type after erasure: (stringList: List)String

That’s because type-erasure makes them effectively the same.

We can overcome this problem in Scala in an elegant and type-safe way using the power of implicits.

Let’s define a type-class for our Magnet to combine elements in our List:

sealed trait CombineMagnet {
  type Result
  def apply() : Result

Now, let’s re-define our combineElements to take an instance of CombineMagnet instead of List:

def combineElements(magnet:CombineMagnet):magnet.Result = magnet()

We have the function defined, so now we need the implementations of our magnet for the types Int and String:

implicit def intCombineMagnet(intList:List[Int]) = new CombineMagnet {
  override type Result = Int
  override def apply(): Result = intList.reduce((i,c) => i+c)
implicit def strCombineMagnet(stringList:List[String]) = new CombineMagnet {
  override type Result = String
  override def apply(): Result = stringList.reduce((s,c)=> s.concat(c))

We’re all set! Let’s call our combine function with lists of different types:


We can see that the function returns results as expected without any errors.

4. Limitations of Magnet Pattern

There are several limitations and drawbacks of using this pattern that make it unsuitable in certain situations. We need to be aware of such scenarios so that we can avoid using them. We can clearly see this pattern introduces additional lines of code and complexity to our program, thus reducing code readability and simplicity.

5. Conclusion

In this short tutorial, we learned what the Magnet pattern is in Scala and how to use it to overcome the problems caused by type erasure happening inside the compiler. Then, we saw some of its drawbacks and limitations so that we can use this pattern only for appropriate use cases and avoid it in other places.

The complete code is available over on GitHub.
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.