What is the Scala Identifier "implicitly"?

Last Updated : 08 May, 2024

The implicit identifier in Scala is an effective tool for retrieving implicit values that are included in the current scope. When implicit arguments are anticipated, implicit values are those that are indicated with the implicit keyword and may be provided to methods or constructors automatically. Gaining an understanding of implicit is essential to efficiently use implicit values in Scala.

Table of Content

Implicit Parameters
Implicit Conversions
Conclusion

Implicit Parameters

Below is the Scala program to implement implicit parameters:

Scala

// Define a case class
case class Config(server: String, port: Int)

// Define an implicit value
implicit val defaultConfig: Config = Config("localhost", 8080)

// Define a method that requires an implicit parameter
def connectToServer(implicit config: Config): Unit = {
  println(s"Connecting to ${config.server}:${config.port}")
}

// Call the method without explicitly passing the implicit parameter
def connectImplicitly(): Unit = {
  connectToServer // Here, implicitly is used to access the implicit value
}

// Call the method
connectImplicitly()

Output:

Implicit Conversions

Below is the Scala program to implement implicit conversions:

Scala

// Define a class
class Celsius(val temperature: Double)

// Define an implicit conversion from Celsius to Fahrenheit
implicit def celsiusToFahrenheit(celsius: Celsius): Double = {
  celsius.temperature * 9 / 5 + 32
}

// Use an implicit conversion
def printFahrenheit(implicit temp: Celsius): Unit = {
  val fahrenheit = implicitly[Celsius] // Access Celsius implicitly
  println(s"${temp.temperature} Celsius is $fahrenheit Fahrenheit")
}

// Create an instance of Celsius
val roomTemperature = new Celsius(25)

// Call the method without passing Celsius explicitly
def printTemperature(): Unit = {
  printFahrenheit(roomTemperature)
}

// Call the method
printTemperature()

Output:

Conclusion

The implicitly identifier in Scala simplifies the usage of implicit values by allowing us to access them without explicitly passing them as parameters. By leveraging implicitly, we can write more concise and expressive code while still benefiting from the power of implicit parameters and conversions. Understanding how to use implicitly effectively is essential for mastering Scala's implicit system.