I have been digging into some Actor modelling in Akka and I came across the usage of the keyword implicit in Scala. Scala, a hybrid functional and object-oriented programming language, is known for its concise syntax and powerful features. Among its arsenal of features, the implicit keyword stands out for its ability to reduce boilerplate and enhance the expressiveness of code. However, for newcomers and even some seasoned programmers, implicit can be shrouded in mystery.

What is really implicit?

In Scala, implicit is a keyword that can be applied to variables, functions, and parameters. It serves 3 primary purposes:

1. Implicit Conversions: Automatically convert one type to another.
2. Implicit Parameters: Automatically pass parameters to a function.
3. Implicit Classes: Enrich existing classes with new functionality without modifying their source code.

Let’s talk about Implicit Conversions

Imagine you asre working with two different types in your application, A and B, and you frequently need to convert from A to B. Instead of manually converting them every time, Scala’s implicit conversions can do the heavy lifting for you. Here is an example:

case class A(value: Int)
case class B(value: Int)

implicit def aToB(a: A): B = B(a.value)

val aInstance = A(5)
val bInstance: B = aInstance // Automatically converted from A to B

In the above snippet, the Scala compiler expects an instance of B but receives an A, and automatically uses the function aToB to apply the conversion

Simplifying Code with Implicit Parameters

Implicit parameters can significantly reduce the verbosity of your code, especially when passing common parameters like configurations or context objects through multiple layers of functions.

implicit val timeout: Int = 5000 // 5 seconds

def fetchData(query: String)(implicit timeout: Int): Unit = {
  println(s"Fetching data for '$query' with timeout: $timeout")
}

fetchData("Scala posts") // No need to explicitly pass the timeout

In the above example, fecthData can be called without explicitly providing the timeout, so that the function call is cleaner and more readeable

Enhancing Classes with Implicit Classes

Scala allows adding new methods to existing classes using implicit classes, a technique often referred to as “pimp my library”. This is particularly useful for adding utility methods to third-party classes or built-in types.

implicit class RichString(val s: String) {
def shout: String = s.toUpperCase + “!”
}

println(“hello”.shout) // Outputs: HELLO!

In this way, RichString implicit class adds a new shout method to the String class, allowing all strings to “shout”.