What functional technique enables not having to pass configuration through functions - scala

Question

As I'm delving more into FP, I'm curious about the 'best' way to store settings that are loaded from config files. I've just been creating a case class with all the necessary config variables and setting that on app start. I then pass that case class into whatever function requires info from it.
However, it seems quite annoying especially when that settings case class has to propagate through many functions. Is there a better way to do this?

Answer 1

Reader monad provides a way of propagating configuration without having to pass it as a parameter throughout all functions that need it. Contrast the following two implementations:
 Config available from context via Reader[Config, String]
object ConfigFunctional extends App {
case class Config(username: String, password: String, host: String)
def encodeCredentials: Reader[Config, String] = Reader { config =>
Base64.getEncoder.encodeToString(s"${config.username}:${config.password}".getBytes())
}
def basicAuth(credentials: String): Reader[Config, String] = Reader { config =>
Http(s"${config.host}/HTTP/Basic/")
.header("Authorization", s"Basic $credentials")
.asString
.body
}
def validateResponse(body: String): Reader[Config, Either[String, String]] = Reader { _ =>
if (body.contains("Your browser made it"))
Right("Credentials are valid!")
else
Left("Wrong credentials")
}
def program: Reader[Config, Either[String, String]] = for {
credentials <- encodeCredentials
response <- basicAuth(credentials)
validation <- validateResponse(response)
} yield validation
val config = Config("guest", "guest", "https://jigsaw.w3.org")
println(program.run(config))
}
Config passed in as an argument
object ConfigImperative extends App {
case class Config(username: String, password: String, host: String)
def encodeCredentials(config: Config): String = {
Base64.getEncoder.encodeToString(s"${config.username}:${config.password}".getBytes())
}
def basicAuth(credentials: String, config: Config): String = {
Http(s"${config.host}/HTTP/Basic/")
.header("Authorization", s"Basic $credentials")
.asString
.body
}
def validateResponse(body: String): Either[String, String] = {
if (body.contains("Your browser made it"))
Right("Credentials are valid!")
else
Left("Wrong credentials")
}
def program(config: Config): Either[String, String] = {
val credentials = encodeCredentials(config)
val response = basicAuth(credentials, config)
val validation = validateResponse(response)
validation
}
val config = Config("guest", "guest", "https://jigsaw.w3.org")
println(program(config))
}
Both implementations should output Right(Credentials are valid!), however notice how in the first implementation config: Config is not a method parameter, for example, contrast encodeCredentials:
def encodeCredentials: Reader[Config, String]
def encodeCredentials(config: Config): String
Config appears in the return type instead of being a parameter. We can interpret this as meaning
"When encodeCredentials runs in the context that provides a
Config, then it will produce a String result."
The "context" here is represented by Reader monad.
Furthermore, notice how Config is not a parameter even in the main business logic
def program: Reader[Config, Either[String, String]] = for {
credentials <- encodeCredentials
response <- basicAuth(credentials)
validation <- validateResponse(response)
} yield validation
We let the methods evaluate in the context containing Config via run function:
program.run(config)
To run above examples we need the following dependencies
scalacOptions += "-Ypartial-unification",
libraryDependencies ++= Seq(
"org.typelevel" %% "cats-core" % "1.6.0",
"org.scalaj" %% "scalaj-http" % "2.4.1"
)
and imports
import cats.data.Reader
import java.util.Base64
import scalaj.http.Http