The Reader monad for dependency injection

the reader monad

function composition in scala
dependency injection with the reader monad
using the reader alongside the cake pattern
possible problems and solutions

composing functions

the only language construct we need

scala> val f = (i: Int) => i*3
f: Int => Int = <function1>

f: Int => Int is just a fancy way of saying Function1[Int, Int]

 def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) }

scala> val f = (i: Int) => i*3
f: Int => Int = <function1>

scala> val g = (i: Int) => i.toString
g: Int => String = <function1>scala> val tripleToString = f andThen gtripleToString: Int => String = <function1>
scala> tripleToString(2)
res0: String = 6

monads

A type with a monad structure defines what it means to chain operations, or nest functions of that type together.

THE READER MONAD

a monad for unary operations
using andThen as a map operation
in the end its just a Function1
scalaz.Reader provides map and flatMap operations

scalaz.reader

scala> import scalaz.Reader
import scalaz.Reader

scala> val f = Reader((i: Int) => i*3)
f: scalaz.Reader[Int,Int] = scalaz.KleisliFunctions$$anon$17@53628ee

new readers can be created with map and flatMap

val g = f map (i => i + 2)
val h = for (i <- g) yield i.toString

dependency injection with the reader monad

define functions requiring a dependency as a Reader with the dependency

let's see an example

trait Users {
  def getUser(id: Int) = Reader((userRepository: UserRepository) =>
    userRepository.get(id)
  )

  def findUser(username: String) = Reader((userRepository: UserRepository) =>
    userRepository.find(username)
  )
}

getUser returns a Reader[UserRepository, User] not a User!

what does that mean?

I'm gonna return a User, when I get a UserRepository

The actual injection is deferred

map, flatmap all the monadic goodness

object UserInfo extends Users {
  def userEmail(id: Int) = {
    getUser(id) map (_.email)
  }

  def userInfo(username: String) = 
    for {
      user <- findUser(username)
      boss <- getUser(user.supervisorId)
    } yield Map(
      "fullName" -> s"${user.firstName} ${user.lastName}",
      "email" -> s"${user.email}",
      "boss" -> s"${boss.firstName} ${boss.lastName}"
    )}

userEmail returns Reader[UserRepository, String]

but we don't have to mention the Repository anywhere except our primitive Readers

multiple dependencies?

trait Repositories {
  def userRepository: UserRepository
  def questionRepository: QuestionRepository
}

Now we just have to change our primitive readers to accept the Repositories instead of a single one

trait Users {
  def getUser(id: Int) = Reader((repos: Repositories) =>
    repos.userRepository.get(id)
  )
}

getUser is now a Reader[Repositories, User]

Injecting the dependency

At an outer level of our application we actually need to inject the dependencies

object Application extends Application(UserRepositoryImpl)

class Application(userRepository: UserRepository) with Users {

  def getUserEmail(id: Int) = Action {
    HttpOk(UserInfo.userEmail(id)(userRepository))
  }

}

why not use it with cake together?

object Application extends Application with UserRepositoryComponentImpl

trait Application extends Controller with Users {
  this: UserRepositoryComponent =>

  def getUserEmail(id: Int) = Action {
    HttpOk(UserInfo.userEmail(id)(userRepository))
  }
}

Cake pattern at the outer edge
Reader monad in the core
Reader monad lets us push the dependency injection from the core to the outer levels too

Problems

what about futures?

Two monads do not combine automatically
Future[Reader[A,B]], Future[Reader[A, Future[B]]] ?!
Better to have reader of futures that we can combine
Monad transformers in scalaz or simple implicit conversions

additional readings and inspiration

Reader monad for dependency injection

Tooling the reader monad (working with Futures)

Reader implementation without scalaz

Talk from Runar Oli Bjarnason how they are using the Reader

(writer of functional programmign in scala)