Trip with monads

Trip with monads
© Pawel Szulc, @rabbitonweb, paul.szulc@gmail.com 1

Why should I write FP code?
1. Modularity
2. Testability
3. Performance
4. Maintainability

FP Building Blocks

FP Building Blocks
case class EitherT[F[_], A, B](
run: F[A / B]
)

FP Building Blocks
run: F[A / B]
)
A / B

FP Building Blocks
run: F[A / B]
)
A __/ B

FP Building Blocks
run: F[A / B]
)
A _( )_/ B

FP Building Blocks
run: F[A / B]
)
A ¯_( )_/¯ B

FP Building Blocks
case class Reader[A, B](
run: A => B
)

FP Building Blocks
case class Kleisli[M[_], A, B](
run: A => M[B]
)

FP Building Blocks
run: A => M[B]
)
type ReaderT[M[_], A, B] = Kleisli[M, A, B]

FP Building Blocks
run: A => M[B]
)
type Reader[A, B] = Kleisli[Id, A, B]

FP Building Blocks
run: A => M[B]
)
type Id[A] = A

FP Building Blocks
case class State[S, A](
run: S => (S, A)
)

FP Building Blocks
case class StateT[M[_], S, A](
run: S => M[(S, A)]
)

FP Building Blocks
case class StateT[M[_], S, A](
run: S => M[(S, A)]
)
type State[A, B] = StateT[Id, A, B]

FP Building Blocks
case class EitherT[F[_], A, B](run: F[A / B])
case class Kleisli[M[_], A, B](run: A => M[B])
case class StateT[M[_], S, A](run: S => M[(S, A)])
type State[A, B] = StateT[Id, A, B]

And now what?

Learning Functional Programming

Let's write FP application!

The App
>
.

The App
> run
.

The App
> run
Using weather service at http://our-super-weather-forcast-app.com
What is the next city?
.

The App
> run
Wroclaw
.

The App
> run
Wroclaw
Forcast for City(Wroclaw) is Temperature(28, Celcius)
Hottest city found so far is (City(Wroclaw), Temperature(28, Celcius))
.

The App
> run
Wroclaw
Gdansk
.

The App
> run
Wroclaw
Gdansk
Forcast for City(Gdansk) is Temperature(34, Celcius)
Hottest city found so far is (City(Gdansk), Temperature(34, Celcius))
.

The App
> run
Wroclaw
Gdansk
kjsdkjssd
.

The App
> run
Wroclaw
Gdansk
kjsdkjssd
Encountered an error: UknownCity(kjsdkjssd)
>

Domain
sealed trait TempUnit
case object Celcius extends TempUnit
case object Fahren extends TempUnit

Domain
case class Temperature(
value: Int,
unit: TempUnit = Celcius
)
case class Forcast(temperature: Temperature)
case class City(name: String)

Third-party
class WeatherClient(host: String, port: Int) {
def forcast(city: City): Forcast = city match {
case City("Wroclaw") =>
Forcast(Temperature(28))
case City("Gdansk") =>
Forcast(Temperature(34))
}
}

Helper classes
case class Config(host: String, port: Int)
sealed trait Error
case class UnknownCity(city: String) extends Error

Helper classes
type Requests = Map[City, Forcast]
object Requests {
def empty: Requests = Map.empty[City, Forcast]
def hottest(requests: Requests): (City, Forcast) = ...
}

Imports
import scalaz._, Scalaz._
import monix.eval.Task
import monix.execution.Scheduler
import shims._

So what do we need?
1. Host & port
2. Input / output
3. City by name (errors)
4. Forcast from third-party
5. Hottest city

Host & port
def host: Reader[Config, String] =
Reader(_.host)
def port: Reader[Config, Int] =
Reader(_.port)

Input / output
def printLn(line: String): Task[Unit] =
Task.delay(println(line))
def readLn: Task[String] =
Task.delay(scala.io.StdIn.readLine)

City by name
def cityByName(cityName: String): Error / City =
cityName match {
case "Wroclaw" =>
/-(City(cityName))
case "Gdansk" =>
/-(City(cityName))
case _ =>
-/(UnknownCity(cityName))
}

Weather forcast
def weather(city: City)(
host: String, port: Int
): Task[Forcast] = Task.delay {
new WeatherClient(host, port).forcast(city)
}

Hottest city
def hottestCity: State[(City, Temperature)] =
State { reqs =>
val temper = Requests.hottest(reqs)
.map(f => f.temperature)
(reqs, temper)
}

Ask city
def askCity: Task[String] = for {
_ <- printLn("What is the next city?")
cityName <- readLn
} yield cityName

def fetchForcast(city: City)(host: String, port: Int): StateReq[Forcast] =
for {
mForcast <- StateT { (reqs: Requests) =>
Task.delay ((reqs, reqs.get(city)))
}
forcast <- StateT { (reqs: Requests) =>
maybeForcast
.cata(_.pure[Task], weather(city)(host, port))
.map (forcast => (reqs, forcast))
}
_ <- StateT { (reqs: Requests) =>
Task.delay ((reqs + (city -> forcast), ()))
}
} yield forcast

Final program
def askFetchJudge =
for {
cityName <- askCity
city <- cityByName(cityName)
h <- host
p <- port
forcast <- fetchForcast(city)(host, port)
_ <- printLn(s"Forcast for $city is ${forcast.temperature}")
hottest <- hottestCity
_ <- printLn(s"Hottest city found so far is $hottest")
} yield ()

Final program
def program = for {
h <- host
p <- port
_ <- printLn(s"Using weather service at http://$h:$p n")
_ <- askFetchJudge.forever
} yield ()

WRONG!

Reality
def askFetchJudge: Effect[Unit] =
for {
cityName <- askCity.liftM[ErrorEitherT].liftM[ConfigReaderT].liftM[RequestsStateT]
city <- EitherT
.fromDisjunction[Task](cityByName(cityName))
.liftM[ConfigReaderT].liftM[RequestsStateT]
h <- StateT[Effect1, Requests, String]((requests: Requests) =>
ReaderT[Effect0, Config, (Requests, String)]((config: Config) =>
EitherT(Task.delay {
((requests, host.run(config))).right[Error]
})))
p <- StateT[Effect1, Requests, Int]((requests: Requests) =>
ReaderT[Effect0, Config, (Requests, Int)]((config: Config) =>
((requests, port.run(config))).right[Error]
})))
forcast <- fetchForcast(city)(h, p)
.mapK[Effect1, Forcast, Requests](
(t: Task[(Requests, Forcast)]) =>
ReaderT[EitherT[Task, Error, ?], Config, (Requests, Forcast)](
κ(EitherT[Task, Error, (Requests, Forcast)](
t.map(_.right[Error])))))
_ <- printLn(s"Forcast for $city is ${forcast.temperature}")
.liftM[ErrorEitherT].liftM[ConfigReaderT].liftM[RequestsStateT]
hottest <- hottestCity.mapK[Effect1, (City, Temperature), Requests](
(t: Task[(Requests, (City, Temperature))]) =>
ReaderT[EitherT[Task, Error, ?],
Config,
(Requests, (City, Temperature))](
κ(EitherT[Task, Error, (Requests, (City, Temperature))](
t.map(_.right[Error])))))
_ <- printLn(s"Hottest city found so far is $hottest")
.liftM[ErrorEitherT]
.liftM[ConfigReaderT]
.liftM[RequestsStateT]
} yield ()

Reality
def program: Effect[Unit] = for {
h <- StateT[Effect1, Requests, String]((requests: Requests) =>
ReaderT[Effect0, Config, (Requests, String)]((config: Config) =>
((requests, host.run(config))).right[Error]
})))
p <- StateT[Effect1, Requests, Int]((requests: Requests) =>
ReaderT[Effect0, Config, (Requests, Int)]((config: Config) =>
((requests, port.run(config))).right[Error]
})))
_ <- printLn(s"Using weather service at http://$h:$p n")
.liftM[ErrorEitherT]
.liftM[ConfigReaderT]
.liftM[RequestsStateT]
_ <- askFetchJudge.forever
} yield ()

"The FP sounds rather like
a mediæval monk, denying
himself the pleasures of life
in the hope that it will
make him virtuous."

Modularity
Testability
Performance
Maintainability

Modularity !
Testability
Performance
Maintainability

Modularity !
Testability !
Performance
Maintainability

Modularity !
Testability !
Performance !
Maintainability

Modularity !
Testability !
Performance !
Maintainability !

def askFetchJudge: Effect[Unit] = ..

def askFetchJudge: Effect[Unit] = ..
type Effect0[A] = EitherT[Task, Error, A]
type Effect1[A] = ReaderT[Effect0, Config, A]
type Effect[A] = StateT[Effect1, Requests, A]

def main(args: Array[String]): Unit = {
val config = Config("localhost", 8080)
val requests = Requests.empty
}
.

val app: Effect[Unit] = program
implicit val io: SchedulerService =
Scheduler.io("io-scheduler")
}
.

app.run(requests).run(config).run
}
.

app.run(requests).run(config).run >>= {
case -/(error) =>
printLn(s"Encountered an error:" +
s"${error.shows}")
case /-(_) => ().pure[Task]
}
}
.

(app.run(requests).run(config).run >>= {
case -/(error) =>
printLn(s"Encountered an error:" +
s"${error.shows}")
}).unsafeRunSync
}
.

Can we do better?

So what do we need?
1. Host & port
2. Input / output
3. City by name (errors)
4. Forcast from third-party
5. Hottest city

Host & port
def host: Reader[Config, String] =
Reader(_.host)
def port: Reader[Config, Int] =
Reader(_.port)

Host & port
def host[F[_]]: F[String] = ?
def port[F[_]]: F[Int] = ?

trait ApplicativeAsk[F[_], E] {
val applicative: Applicative[F]
def ask: F[E]
def reader[A](f: E => A): F[A]
}

def ask: F[E]
}
type ConfigAsk[F[_]] = ApplicativeAsk[F, Config]

def host[F[_]]: F[String] = ?
def port[F[_]]: F[Int] = ?

def host[F[_]: ConfigAsk]: F[String] =
ConfigAsk[F].reader(_.host)
def port[F[_]: ConfigAsk]: F[Int] =
ConfigAsk[F].reader(_.port)

def host[F[_]: ConfigAsk]: F[String] =
ConfigAsk[F].reader(_.host)
def port[F[_]: ConfigAsk]: F[Int] =
ConfigAsk[F].reader(_.port)
def ask: F[E]
}

City by name
def cityByName(cityName: String): Error / City =
cityName match {
case "Wroclaw" => /-(City(cityName))
case "Gdansk" => /-(City(cityName))
case _ => -/(UnknownCity(cityName))
}

City by name
def cityByName[F[_]](
cityName: String
): F[City] =
}

City by name
def cityByName[F[_]:Applicative](
cityName: String
): F[City] = cityName match {
case "Wroclaw" => City(cityName).pure[F]
case "Gdansk" => City(cityName).pure[F]
case _ => ???
}

trait ApplicativeError[F[_], E] {
def raiseError[A](e: E): F[A]
}

trait ApplicativeError[F[_], E] {
def raiseError[A](e: E): F[A]
}
type ErrorHandler[F[_]] = ApplicativeError[F, Error]

City by name
def cityByName[F[_]:Applicative](
cityName: String
case _ => ???
} .

City by name
def cityByName[F[_]: Applicative: ErrorHandler](
cityName: String
case _ => ErrorHandler[F].raiseError(UnknownCity(cityName))
}

Hottest city
def hottestCity: State[(City, Temperature)] =
State { reqs =>
val temper = Requests.hottest(reqs)
.map(f => f.temperature)
(reqs, temper)
}

Hottest city
def hottestCity[F[_]]: F[(City, Temperature)]= ?

trait MonadState[F[_], S] {
val monad: Monad[F]
def get: F[S]
def set(s: S): F[Unit]
def inspect[A](f: S => A): F[A]
def modify(f: S => S): F[Unit]
}

val monad: Monad[F]
def get: F[S]
def set(s: S): F[Unit]
def modify(f: S => S): F[Unit]
}
type RequestsState[F[_]] = MonadState[F, Requests]

Hottest city
def hottestCity[F[_]]: F[(City, Temperature)]= ?

Hottest city
def hottestCity[
F[_]: RequestsState
]: F[(City, Temperature)] =

Hottest city
def hottestCity[
F[_]: RequestsState
RequestsState[F].inspect(reqs =>
Requests.hottest(reqs).map(_.temperature)
)

Hottest city
def hottestCity[
F[_]: RequestsState
RequestsState[F].inspect(reqs =>
Requests.hottest(reqs).map(_.temperature)
)
// (...)
}

MTL© Pawel Szulc, @rabbitonweb, paul.szulc@gmail.com 86

Input / output
def readLn: Task[String] =

Input / output
trait Console[F[_]] {
def readLine: F[String]
def printLn(line: String): F[Unit]
}

Ask City
def askCity[F[_]: Console: Monad]: F[String] =
for {
_ <- Console[F].printLn("What is the next city?")
cityName <- Console[F].readLine
} yield cityName

Weather forcast
def weather(city: City)(
host: String, port: Int
): Task[Forcast] = Task.delay {
new WeatherClient(host, port).forcast(city)
}

Weather forcast
trait Weather[F[_]] {
def forcast(city: City): F[Forcast]
}

Fetch forcast
def fetchForcast[F[_]: Weather: RequestsState: Monad](city: City): F[Forcast] =
for {
maybeForcast <- RequestsState[F].inspect(_.get(city))
forcast <- maybeForcast.cata(
_.pure[F],
Weather[F].forcast(city)
)
_ <- RequestsState[F].modify(_ + (city -> forcast))
} yield forcast

Tagless final

Final program
def askFetchJudge[F[_]: Console: Weather :
RequestsState: ErrorHandler:Monad]: F[Unit] =
for {
cityName <- askCity[F]
city <- cityByName[F](cityName)
forcast <- fetchForcast[F](city)
_ <- Console[F].printLn(s"Forcast for $city is ${forcast.temperature}")
hottest <- hottestCity[F]
_ <- Console[F].printLn(s"Hottest city found so far is $hottest")
} yield ()

Final program
def program[F[_]: ConfigAsk: Console: Weather:
RequestsState:ErrorHandler:Monad]: F[Unit] =
for {
h <- host[F]
p <- port[F]
_ <- Console[F].printLn(s"Using weather service at http://$h:$p")
_ <- askFetchJudge[F].forever
} yield ()

type Effect[A] = ???
val app: Effect[Unit] = program[Effect]
}

type Effect[A] = Task[A]
}

implicit val weather = ???
}

object Weather {
def monixWeather(config: Config): Weather[Task] =
new Weather[Task] {
val client: WeatherClient = new
WeatherClient(config.host, config.port)
def forcast(city: City): Task[Forcast] =
Task.delay {
client.forcast(city)
}
}
}

implicit val weather = ???
}

implicit val weather = Weather.monixWeather(config)
}

implicit val console = ???
}

object Console {
val monixConsole: Console[Task] =
new Console[Task] {
def readLine: Task[String] =
}
}

implicit val console = ???
}

implicit val console = Console.monixConsole
}

type Effect[A] = StateT[Task, Requests, A]
}

type Effect1[A] = ReaderT[Task, Config, A]
}

}

(app.run(requests).run(config).run >>= {
case -/(error) => console.printLn(s"Encountered an error: ${error.shows}")
}).unsafeRunSync
}

Modularity
Testability
Performance
Maintainability

Modularity ✅
Testability
Performance
Maintainability

def askFetchJudge[F[_]: Console: Weather :
RequestsState: ErrorHandler:Monad]: F[Unit] =
for {
cityName <- askCity[F]
city <- cityByName[F](cityName)
forcast <- fetchForcast[F](city)
_ <- Console[F].printLn(s"Forcast for $city is ${forcast.temperature}")
hottest <- hottestCity[F]
_ <- Console[F].printLn(s"Hottest city found so far is $hottest")
} yield ()

Modularity ✅
Testability
Performance
Maintainability

Modularity ✅
Testability ✅
Performance
Maintainability

Modularity ✅
Testability ✅
Performance "
Maintainability

Modularity ✅
Testability ✅
Performance "
Maintainability ✅

Can we do better?

}

private[twm] class AtomicMonadState[S](atomic: Atomic[S])
extends MonadState[Task, S] {
val monad: Monad[Task] = Monad[Task]
def get: Task[S] = Task.delay(atomic.get)
def set(s: S): Task[Unit] = Task.delay(atomic.set(s))
def inspect[A](f: S => A): Task[A] = Task.delay(f(atomic.get))
def modify(f: S => S): Task[Unit] = Task.delay(atomic.transform(f))
}
object AtomicMonadState {
def create[S <: AnyRef](s: S): AtomicMonadState[S] =
new AtomicMonadState(AtomicAny[S](s))
}

}

type Effect[A] = ReaderT[Effect0, Config, A]
implicit val requestsState =
AtomicMonadState.create(Requests.empty)
}

object ApplicativeAsk {
def constant[
F[_]:Applicative, E
](e: E): ApplicativeAsk[F, E] =
new DefaultApplicativeAsk[F, E] {
val applicative: Applicative[F] = Applicative[F]
def ask: F[E] = applicative.point(e)
}
}

type Effect[A] = ReaderT[Effect0, Config, A]
}

type Effect[A] = EitherT[Task, Error, A]
implicit val configAsk =
ApplicativeAsk.constant[Task, Config](config)
}

Modularity ✅
Testability ✅
Performance "
Maintainability ✅

Modularity ✅
Testability ✅
Performance ✅ *
Maintainability ✅

Can we do better?

type Effect[A] = EitherT[Task, Error, A]
Last frontier

Why?

Why?
1. Performance
2. Two channels error handling

Introducing IO[E, A]

Introducing IO[E, A]
https://github.com/scalaz/scalaz-zio
https://github.com/LukaJCB/cats-bio

Modularity ✅
Testability ✅
Performance ✅ *
Maintainability ✅

Modularity ✅
Testability ✅
Performance ✅
Maintainability ✅

Announcements

Announcements
1. https://github.com/scalaz/scalaz-mtl
2. http://rabbitonweb.com/

Thank you very much
Pawel Szulc
@rabbitonweb

Trip with monads

Recommended

Recommended

More Related Content

More from Pawel Szulc

More from Pawel Szulc (20)

Recently uploaded

Recently uploaded (20)

Trip with monads