Classy Guide to Monad Transformers in Scala

Classy Monad Transformers (Stop Eﬀ’ing)
Sukant Hajra / @shajra
March 24, 2017
Sukant Hajra / @shajra Classy Monad Transformers (Stop Eﬀ’ing) March 24, 2017 1 / 46

Goals
introduce monad transformers
illustrate ergonomics in Scala
recommend a usage
begin comparison with alternatives

Quick mention
Figure 1: My Employer

Materials
This presentation and all code is
at github.com/shajra/shajra-presentations/tree/master/scala-mtl
compiler-checked by Rob Norris’s sbt-tut plugin.

In lieu of time
Assuming knowledge of
Scala implicits
type classes
for-yield sugar w.r.t. Monad.

Monads, Explicitly
1trait Monad[M[_]] {
3def pure[A](a: A): M[A]
5def flatMap[A, B](ma: M[A])(f: A => M[B]): M[B] =
6flatten(map(ma)(f))
8def flatten[A](mma: M[M[A]]): M[A] =
9flatMap(mma)(identity)
11def map[A, B](ma: M[A])(f: A => B): M[B] =
12flatMap(ma)(f andThen pure)
14}
Note: the Monad type class has three laws
very important, but elided for time

Monad syntax with implicits
For convenience (e.g. with for-yield)
1implicit class OpsA[A](a: A) {
3def pure[M[_]](implicit M: Monad[M]): M[A] =
4M pure a
6}
8implicit class
9MonadOps[M[_], A](ma: M[A])(implicit M: Monad[M]) {
11def map[B](f: A => B): M[B] =
12M.map(ma)(f)
14def flatMap[B](f: A => M[B]): M[B] =
15M.flatMap(ma)(f)
17}

Towards Transformers

Where people come from
Enterprise Java
1trait DbConn; trait MetricsConn
3class UsersDao @Inject() (db: DbConn)
5class InsightsDao @Inject()
6(db: DbConn, metrics: MetricsConn)
8class App @Inject() (users: UsersDao, insights: InsightsDao)
Complaints
no compile-time safety
lacks composition with other FP practices

A ﬁrst response
Have you tried passing a parameter to a function?
1trait DbConn; trait MetricsConn
3case class User(name: String)
4case class Insight(desc: String)
6def newUser(db: DbConn)(name: String): User = ???
8def getInsight
9(db: DbConn, metrics: MetricsConn)(user: User)
10: Insight = ???
12def runApp(db: DbConn, metrics: MetricsConn): Unit = ???
Observations
safer (no runtime reﬂection)
feels like “manual” dependency injection

A second response
Passing a parameter is just the “reader” monad
1case class Reader[R, A](run: R => A)

A second response
Reader’s monad instance
1implicit def readerMonad[R]: Monad[Reader[R, ?]] =
2new Monad[Reader[R, ?]] {
4def pure[A](a: A): Reader[R, A] =
5Reader { _ => a }
7override def flatMap[A, B]
8(ra: Reader[R, A])(f: A => Reader[R, B])
9: Reader[R, B] =
10Reader { r => f(ra run r) run r }
12}

A second response
1trait DbConfig; trait MetricsConfig
3case class AppConfig(db: DbConfig, metrics: MetricsConfig)
5def newUser(name: String): Reader[AppConfig, User] = ???
7def getInsight(user: User): Reader[AppConfig, Insight] = ???
9def showInsight
10(insight: Insight): Reader[AppConfig, Unit] = ???
12def app: Reader[AppConfig, Unit] =
13for {
14u <- newUser("Sukant")
15i <- getInsight(u)
16_ <- showInsight(i)
17} yield ()

A second response
Benefits
Plumbing is hidden a little.
We’re getting some composition.
Complaints
A global config is anti-modular.
Side-effects! Is this even FP?

Eﬀect-tracking types
Naive implementation for presentation (stack unsafe)
1class IO[A](a: => A) {
2def unsafeRun: A = a
3}
5object IO { def apply[A](a: => A) = new IO(a) }
7implicit def ioMonad: Monad[IO] =
8new Monad[IO] {
9def pure[A](a: A): IO[A] = IO(a)
11(ioa: IO[A])(f: A => IO[B]): IO[B] =
12IO(f(ioa.unsafeRun).unsafeRun)
13}

Eﬀect-tracking types
No side-eﬀects while composing
1def getTime: IO[Long] = IO { System.currentTimeMillis }
2def printOut[A](a: A): IO[Unit] = IO { println(a) }
4def sillyIO: IO[Unit] =
5for {
6t <- getTime
7_ <- printOut(t)
8_ <- printOut(t)
9} yield ()
Run at the “end of the world”
1scala> sillyIO.unsafeRun
21490293856842
31490293856842

Thus far we have
Two monads
Reader passes in a parameters
IO tracks an eﬀect
Is composing them useful?
Reader[IO[A]]

Let’s compose our monads
But in general, monads don’t compose
1case class Compose[F[_], G[_], A](fga: F[G[A]])
3def impossible[F[_] : Monad, G[_] : Monad]
4: Monad[Compose[F, G, ?]] = ???
Even if we can flatten F[F[A]] and G[G[A]]
It’s hard to flatten F[G[F[G[A]]]].
Can we compose IO and Reader specifically?
Yes, that’s exactly what monad transformers do.

Many monads have respective transformers
Reader’s transformer — ReaderT
1case class ReaderT[R, M[_], A](run: R => M[A])

ReaderT’s monad instance
Depends on inner type’s monad instance
1implicit def readerTMonad[R, M[_]]
2(implicit M: Monad[M]): Monad[ReaderT[R, M, ?]] =
4new Monad[ReaderT[R, M, ?]] {
6def pure[A](a: A): ReaderT[R, M, A] =
7ReaderT { _ => M.pure(a) }
10(ma: ReaderT[R, M, A])(f: A => ReaderT[R, M, B])
11: ReaderT[R, M, B] =
12ReaderT { r => M.flatMap(ma run r) { f(_) run r } }
14}

We can create “stacked” monads
Composing a monad stack
1type Stack[A] = ReaderT[Int, IO, A]
3val concretelyBuilt: Stack[(String, Int, Long)] =
4for {
5c <- "hi".pure[Stack]
6r <- ReaderT { (r: Int) => r.pure[IO] } // ugly
7t <- ReaderT { (_: Int) => getTime } // ugly
8} yield (c, r, t)
Running a monad stack
1scala> concretelyBuilt.run(1).unsafeRun
2res16: (String, Int, Long) = (hi,1,1490293857180)

A useful typeclass for readers
1trait MonadReader[R, M[_]] {
3def monad: Monad[M]
5def ask: M[R]
6def local[A](ma: M[A])(f: R => R): M[A]
8}
10object MonadReader {
11def ask[M[_], R](implicit MR: MonadReader[R, M]): M[R] =
12MR.ask
13}
Note: the MonadReader type class has laws
very important, but elided for time

Creating MonadReader for ReaderT
1implicit def readerTMonadReader[R, M[_]]
2(implicit M: Monad[M])
3: MonadReader[R, ReaderT[R, M, ?]] =
4new MonadReader[R, ReaderT[R, M, ?]] {
6val monad = readerTMonad(M)
8def ask: ReaderT[R, M, R] = ReaderT { _.pure[M] }
10def local[A]
11(ma: ReaderT[R, M, A])(f: R => R): ReaderT[R, M, A] =
12ReaderT { ma run f(_) }
14}

Using stacks with parametric polymorphism
Stack not speciﬁed, only constrained
1def abstractlyBuilt[M[_] : Monad : MonadReader[Int, ?[_]]]
2: M[(String, Int)] =
3for {
4c <- "hi".pure[M]
5r <- MonadReader.ask[M, Int]
7// can't do this yet
8// t <- ReaderT { (_: Int) => getTime }
10// nicer syntax would be
11// getTime.liftBase[M]
13} yield (c, r)
Stack speciﬁed when run
1scala> abstractlyBuilt[Stack].run(1).unsafeRun
2res18: (String, Int) = (hi,1)

One more useful lift
For lifting your base monad
1trait MonadBase[B[_], M[_]] {
3def monadBase: Monad[B]
4def monad: Monad[M]
6def liftBase[A](base: B[A]): M[A]
8}

A lift behind the scenes
People used to complain about this
1trait MonadTrans[T[_[_], _]] {
2def liftT[G[_] : Monad, A](a: G[A]): T[G, A]
3}
But now it can be internal plumbing
Don’t lift too much!
With the SI-2712 ﬁx, you don’t have to

Many other transformers
Transformer Underlying Type class
IdentityT[M[_], A] M[A]
ReaderT[S, M[_], A] R =>M[A] MonadReader[R, M[_]]
StateT[S, M[_], A] S =>M[(S, A)] MonadState[S, M[_]]
OptionT[M[_], A] M[Option[A]] MonadOption[E, M[_]]
EitherT[E, M[_], A] M[Either[E,A]] MonadError[E, M[_]]
ContT[M[_], A] (A =>M[R])=>M[R] MonadCont[M[_]]
. . . . . . . . .

Some transformers commute eﬀects
But we end up with O(n2
) to support them
1implicit def readerTMonadState[R, S, M[_]]
2(implicit MS: MonadState[S, M])
3: MonadState[S, ReaderT[R, M, ?]] =
4??? // can be implemented lawfully
Not all transformers commute eﬀects
1implicit def contTMonadError[R, E, M[_]]
2(implicit ME: MonadError[E, M])
3: MonadError[E, ContT[M, ?]] =
4??? // would break MonadError laws if implemented

What have we got thus far?
Improvements
separations of concerns (Reader from IO)
no side-eﬀects
Remaining Complaint
still using a global conﬁguration

Classy Monad Transformers Example

Setup
Using a fork of Aloïs Cochard’s “scato-style” Scalaz 8
1import scalaz.Prelude.Base._
Notable diﬀerences
minimal subtyping
SI-2712 ﬁxed!

Some abstractions
Our conﬁguration from before
1case class DbConfig()
2case class MetricsConfig()
3case class AppConfig(db: DbConfig, metrics: MetricsConfig)

Don’t use transformer class directly
App-level type classes
1trait MonadDb[M[_]] {
2def monadBase: MonadBase[IO, M]
3def dbConfig: M[DbConfig]
4}
6trait MonadMetrics[M[_]] {
7def monadBase: MonadBase[IO, M]
8def metricsConfig: M[MetricsConfig]
9}

Scato-encoding isn’t perfect
Because we’re not subtyping
1trait AppHierarchy0 extends scalaz.BaseHierarchy {
2implicit def metricsMonadBase[M[_]]
3(implicit M: MonadMetrics[M]): MonadBase[IO, M] =
4M.monadBase
5}
7trait AppHierarchy1 extends AppHierarchy0 {
8implicit def dbMonadBase[M[_]]
9(implicit M: MonadDb[M]): MonadBase[IO, M] =
10M.monadBase
11}
13object AppHierarchy extends AppHierarchy1
14import AppHierarchy._

Make an “app” monad
Use whatever stack makes sense
1type AppStack[A] = ReaderT[AppConfig, IO, A]
2case class App[A](run: AppStack[A])

Make instances for the “app” monad
Haskell’s NewTypeDeriving would be nice here
1implicit val appInstances
2: MonadDb[App] with MonadMetrics[App] =
3new MonadDb[App] with MonadMetrics[App] {
4def monadBase =
5new MonadBaseClass[IO, App] with
6MonadClass.Template[App] with
7BindClass.Ap[App] {
8def pure[A](a: A): App[A] = App(a.pure[AppStack])
9def flatMap[A, B]
10(ma: App[A])(f: A => App[B]): App[B] =
11App(ma.run.flatMap(f andThen { _.run }))
12def liftBase[A](base: IO[A]) =
13App(base.liftBase[AppStack])
14def monadBase = Monad[IO]
15}
16def ask = MonadReader.ask[AppStack, AppConfig]
17def dbConfig = App(ask.map { _.db })
18def metricsConfig = App(ask.map { _.metrics })
19}

Write agnostic computations
Low-level IO calls
1case class User(name: String)
2case class Insight(desc: String)
4def lowLevelMakeUser
5(db: DbConfig, name: String): IO[User] =
6User(name).pure[IO]
8def lowLevelGetInsight
9(db: DbConfig, metrics: MetricsConfig, user: User)
10: IO[Insight] =
11IO {
12val username = System getenv "USER"
13Insight(s"likes username: ${username}")
14}

Mid-level composition
1def makeUser[M[_]]
2(name: String)(implicit D: MonadDb[M]): M[User] =
3for {
4conf <- D.dbConfig
5user <- lowLevelMakeUser(conf, name).liftBase[M]
6} yield user
8def getInsight[M[_]]
9(user: User)(implicit D: MonadDb[M], M: MonadMetrics[M])
10: M[Insight] =
11for {
12db <- D.dbConfig
13metrics <- M.metricsConfig
14insight <-
15lowLevelGetInsight(db, metrics, user).liftBase[M]
16} yield insight

One more mid-level
1def showInsight[M[_] : MonadBase[IO, ?[_]]]
2(user: User, insight: Insight): M[Unit] =
3IO{ println(s"${user.name} ${insight.desc}") }.liftBase[M]
Our ﬁnal application
1def app[M[_] : MonadDb : MonadMetrics]: M[Unit] =
2for {
3user <- makeUser[M]("Sukant")
4insight <- getInsight[M](user)
5_ <- showInsight[M](user, insight)
6} yield ()

The end of the world
1val conf = AppConfig(DbConfig(), MetricsConfig())
1scala> app[App].run.run(conf).unsafeRun
2Sukant likes username: shajra

Eﬀect Commutativity

We don’t have to specify a stack order
1type StateEff[F[_]] = MonadState[Int, F]
2type ErrorEff[F[_]] = MonadError[String, F]
4def tryMtl[F[_] : ErrorEff : StateEff] = {
5val attempt =
6for {
7_ <- 1.put[F]
8_ <- "oh noes".raiseError[F, Unit]
9} yield ()
10attempt.handleError(_ => ().pure[F])
11}

Diﬀerent stacks, diﬀerent results
Stack Representation
StateT[Int, EitherT[String, Identity, ?], A] S =>M[Either[E, (S, A)]]
EitherT[String, StateT[Int, Identity, ?], A] S =>M[(S, Either[E, A])]
1type StackSE[A] =
2StateT[Int, EitherT[String, Identity, ?], A]
3type StackES[A] =
4EitherT[String, StateT[Int, Identity, ?], A]
1scala> tryMtl[StackSE].run(0).run.run
2res1: scalaz./[String,(Int, Unit)] = /-((0,()))
4scala> tryMtl[StackES].run.run(0).run
5res2: (Int, scalaz./[String,Unit]) = (1,/-(()))

Trying with Eff
1import cats.data._; import cats.syntax.all._
2import org.atnos.eff._; import org.atnos.eff.all._
3import org.atnos.eff.syntax.all._
5type StateEff[A] = State[Int, A]
6type ErrorEff[A] = Either[String, A]
8def tryEff[R]
9(implicit S: StateEff |= R , W: ErrorEff /= R)
10: Eff[R, Unit] = {
11val attempt: Eff[R, Unit] =
12for {
13_ <- put(1)
14_ <- left[R, String, Unit]("oh noes")
15} yield ()
16catchLeft[R, String, Unit](attempt) { _ =>
17().pure[Eff[R, ?]]
18}
19}

By default, interpretation locked in
1scala> type StackSE = Fx.fx2[StateEff, ErrorEff]
2defined type alias StackSE
4scala> type StackES = Fx.fx2[ErrorEff, StateEff]
5defined type alias StackES
7scala> tryEff[StackSE].runState(0).runEither.run
8res2: scala.util.Either[String,(Unit, Int)] = Right(((),1))
10scala> tryEff[StackSE].runEither.runState(0).run
11res3: (scala.util.Either[String,Unit], Int) = (Right(()),1)
13scala> tryEff[StackES].runState(0).runEither.run
14res4: scala.util.Either[String,(Unit, Int)] = Right(((),1))
16scala> tryEff[StackES].runEither.runState(0).run
17res5: (scala.util.Either[String,Unit], Int) = (Right(()),1)

Wrapping up

Classy Guide to Monad Transformers in Scala

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Classy Guide to Monad Transformers in Scala

Similaire à Classy Guide to Monad Transformers in Scala (20)

Dernier

Dernier (20)

Classy Guide to Monad Transformers in Scala