ZIO: Powerful and Principled Functional Programming in Scala

Plan
ZIO Library
Effects
Pure
Functions
Data
Structures
Built on ZIO

● ZIO is a zero-dependency Scala library for asynchronous and
concurrent programs using purely functional approach.
2
● Lets you build scalable, resilient, and reactive applications
that meet the needs of your business.

● Interaction with the real World
● Hard to reason about
● Hard to test
● Refactoring
● Programming without effects is useless
3
Effectful Program
{
Statement1
Statement2
Statement3
...
}

4
Effectful Program
Executing Describing
Execute effects Describe effects
Data
def main
unsafeRun
{
Statement1
Statement2
Statement3
}
for {
st1 <- Statement1
st2 <- Statement2
st3 <- Statement3
} yield ()

Effectful Program
def main: Unit = {
println("Good morning, what is your name?")
val name = readLine()
println(s"Good to meet you, $name!")
}
val main = for {
_ <- putStrLn("Good morning, " +
"what is your name?")
name <- getStrLn
_ <- putStrLn(s"Good to meet you, $name!")
} yield ()

Effectful Program
val main = for {
_ <- putStrLn("Good morning, " +
"what is your name?")
name <- getStrLn
_ <- putStrLn(s"Good to meet you, $name!")
} yield ()
def main: Unit = {
println("Good morning, what is your name?")
val name = readLine()
println(s"Good to meet you, $name!")
}

7
Pure function
Properties of pure functions:
● Total
● Deterministic
● Free of side effects

8
Pure function
def parseInt(s: String): Int = s.toInt

9
parseInt("Hello!")
[error] java.lang.NumberFormatException:
For input string: "Hello!"
NOT TOTAL!
Pure function

10
Pure function
def parseInt(s: String): Option[Int]
=
Try(s.toInt).toOption
TOTAL

11
Pure function
def addOne(x: Int): Int = Random.nextInt(x) + 1

12
def addOne(x: Int): Int = Random.nextInt(x) + 1 addOne(10)
> 4
addOne(10)
> 6
addOne(10)
> 2
NON DETERMINISTIC!
Pure function

13
Pure function
def addOne(x: Int): Int = x + 1
DETERMINISTIC

14
Pure function
def makeCoffee(p: Payment, cc: CreditCard):
Coffee = {
val cup = new Coffee()
p.charge(cc, cup.price)
cup
}

15
SIDE EFFECT!
Pure function
Coffee = {
cup
}

16
Pure function
FREE OF SIDE EFFECT
Coffee = {
cup
}
final case class Charge(cc: CreditCard, price: Double)
def makeCoffee(cc: CreditCard): (Coffee, Charge) = {
(cup, Charge(cc, cup.price))
}

17
Pure functions
def parseInt(s: String): Option[Int] =
Try(s.toInt).toOption
def addOne(x: Int): Int = x + 1
def makeCoffee(cc: CreditCard): (Coffee, Charge) =
{
(cup, Charge(cc, cup.price))
}
Non-pure functions
def makeCoffee(withSugar: Option[Int],
p: Payment, cc: CreditCard): Coffee = {
val cup =
withSugar.fold(Coffee(0))(n => Coffee(n))
cup
}
def program(): = { } def program(): = { }
Pure function

20
IO is an immutable data structure that describes an effectful
program that may:
● fail with an E
● run forever
● produce a single A
IO [E, A]

21
parseInt("hello") //fails with NumberFormatException
IO [E, A]

throw new Exception("error")
IO [E, A]

trait IO[E, A] { self =>
def map[B](f: A => B): IO[E, B]
def flatMap[E, B](f0: A => IO[E, B]): IO[E, B]
...
}
object IO {
def fail[E](error: E): IO[E, Nothing] = ???
def succeed[A](a: A): IO[Nothing, A] = ???
...
}
IO [E, A]

IO describes the following effects:
● Errors
throw new Exception("error")
val failedIO: IO[Exception, Nothing] =
IO.fail(new Exception("error"))
IO [E, A]

● Errors
● Pure values
val number: Int= 1
val number: IO[Nothing, Int] = IO.succeed(1)
IO [E, A]

● Errors
● Pure Values
● Synchronous Effect
println("hello")
val toInt: IO[Nothing, Unit] =
IO.effectTotal(println("hello"))
IO [E, A]

● Errors
● Pure Values
"hello".toInt
val parseInt: IO[Throwable, Int] =
IO.effect("hello".toInt)
IO [E, A]

● Errors
● Pure Values
● Asynchronous Effects
Future(4)
IO.effectAsync[Nothing, Int](_(Completed(4)))
IO [E, A]

● Errors
● Pure Values
● Concurrent Effects
val service: ExecutorService =
Executors.newFixedThreadPool(2)
service.submit(t1)
service.submit(t2)
def task(i: Int) = new Thread(
new Runnable {
def run() {
???
}
})
val task: IO[Throwable, (A, B)] = t1.zipPar(t2)
IO [E, A]

● Errors
● Pure Values
● Resource Effects
val f: File = openFile()
try {
compute(f)
}
finally {
closeFile(f)
}
IO.bracket(openFile)(closeFile(_)) { file =>
compute(f)
}
IO [E, A]

● Errors
● Pure Values
● Defects
Throw new FatalError
IO.die(FatalError)
IO [E, A]

● Errors
● Pure Values
● Defects
● Contextual
def program[F[_]: Console: Monad] =
Console[F].println("Hello World")
val sayHello: ZIO[Console, Nothing, Unit] =
console.putStrLn("Hello World")
IO [E, A]

val parseInt: IO[String, Int] =
IO.effect("hello".toInt).catchSome{
case e: NumberFormatException => IO.fail(e.getMessage)
}
Error Handling

val parseInt: IO[String, Int] =
IO.effect("hello".toInt).catchAll(e => IO.fail(e.getMessage))
Error Handling

val value: IO[Nothing, Int] =
parseInt.either.map {
case Left(_) => -1
case Right(v) => v
}
Error Handling

parseInt.option.map {
case None => -1
case Some(v) => v
}
Error Handling

Error Handling
parseInt.fold(_ => -1, v => v)

Error Handling
parseInt.foldM(IO.succeed(-1), IO.succeed(_))

IO [E, A]
IO is interpreted by the IO runtime system into
effectful interactions with the external world.
● unsafeRun
● In your application’s main function (App
provides this functionality automatically).
def main(args: Array[String]): Unit =
println("Hello")
def main(args: Array[String]): Unit =
unsafeRun(IO.effect(println("Hello")))

Fiber
Fiber is a lightweight version of thread to deal with
concurrency.

Fiber
JVM Thread
OS Thread
ZIO Fiber
Fiber Model

trait Fiber[E, A] {
def join: IO[E, A]
def interrupt: IO[Nothing, Exit[E, A]]
def poll: IO[Nothing, Option[Exit[E, A]]]
}
trait IO[E, A] {
def fork: IO[Nothing, Fiber[E, A]]
}
object IO {
def forkAll[E, A](as: Iterable[IO[E, A]): IO[Nothing, Fiber[E, List[A]]]
}
Fiber

def process: IO[Nothing, Fiber[Error, Nothing]] =
(for {
ev <- receive
_ <- ev match {
case NameChange(name) => updateNameDB(name)
case UserDeleted(id) => deleteUser(id)
}
_ <- LoggerIO.info(s"receive Event $ev")
} yield ()).forever.fork
Fiber

(for {
f <- createUser(usr).fork
...
io <- f.join
...
} yield ())
Fiber

(for {
f <- IO.forkAll(users.map(usr => createUser(usr)))
...
_ <- f.join
...
} yield ()).foldM(
err => loggerIO.warn(err),
succ => LoggerIO.info(s"All users are created successfully"))
Fiber

for {
f <- readUsers.fork
...
v <- check(usr).foldM(_ => f.interrupt, createUser(usr))
...
} yield ()
Fiber

trait IO[E, A] {
def zipPar(that: IO[E, B]): IO[E, (A, B)]
}
Parallelism
object IO {
def collectAllPar(as: Iterable[IO[E, A]]): IO[E, List[A]]
def foreachPar[E, A, B](as: Iterable[A])(fn: A => IO[E, B]): IO[E, List[B]]
}
val profile: IO[Error, List[Information]] =
IO.collectAllPar(loadName(user) :: loadPicture(user) :: Nil)
val profileAndFriends: IO[Error, (UserInfo, List[Friend])] = infoUser.zipPar(friendList(user))
val newProfile: IO[Error, List[Profile]] = IO.foreachPar(readUser :: readImage)(createProfile)

trait IO[E, A] {
def race(that: IO[E, A]): IO[E, A]
}
Concurrency
object IO {
def raceAll(as: Iterable[IO[E, A]]): IO[E, A]
}
val availableService: IO[Error, Service] = IO.raceAll(services.map(_.await))
val fastTask: IO[Error, Task] = task1 race task2

Promise
● A Promise is a variable that can be set exactly once.
● Promises are used to build higher level concurrency
primitives.

Promise
By default the state of Promise is Pending, once it fails or succeeds the
state changes to Done.
`done`: completes the promise with the specified result.
A Promise is an asynchronous variable that
can be set only once.

Promise
trait Promise[E, A] {
def await: IO[E, A]
def poll: IO[Nothing, Option[IO[E, A]]]
def succeed(a: A): IO[Nothing, Boolean]
def fail(e: E): IO[Nothing, Boolean]
def interrupt: IO[Nothing, Boolean]
def done(io: IO[E, A]): IO[Nothing, Boolean]
...
}
object Promise {
def make[E, A]: IO[Nothing, Promise[E, A]] = ???
}

Chronometer
unsafeRun(
for {
chrono <- Chrono.start
_ <- chrono.run
_ <- chrono.stop.delay(duration)
} yield ()
)

Chronometer
case class Chrono(p: Promise[Nothing, Unit]) {
val run: IO[Nothing, Unit] =
for {
loop <- IO.foreach(1 to 60)(
i =>
console.putStrLn(s"$i").delay(1.second) *>
IO.succeed(i))
.forever.fork
_ <- p.await.flatMap(_ => loop.interrupt).fork
} yield ()
val stop: IO[Nothing, Boolean] = p.succeed(())
}
object Chrono {
def start: IO[Nothing, Chrono] = Promise.make[Nothing, Unit].map(Chrono(_))
}

Ref
Ref[A] is a mutable reference to a value of type A.
All operations on a Ref are atomic and thread-safe, providing a reliable
foundation for synchronizing concurrent program.

Ref
object Ref {
def make[A](a: A): IO[Nothing, Ref[A]] = ???
}
trait Ref[A] {
def get: IO[Nothing, A]
def set(a: A): IO[Nothing, Unit]
def update(f: A => A): IO[Nothing, A]
def updateSome(pf: PartialFunction[A, A]): IO[Nothing, A]
def modify[B](f: A => (B, A)): IO[Nothing, B]
def modifySome[B](default: B)(pf: PartialFunction[A, (B, A)]): IO[Nothing, B]
}

Candy machine
Input
sealed trait Input
case object Coin extends Input
case object Turn extends Input
State
case class Machine(
locked: Boolean,
candies: Int,
coins: Int
)
Note: This example is from Functional Programming in Scala (the red book)

Candy machine
case class System (ref: Ref[Machine]) {
def simulate(inputs: List[Input]): IO[Nothing, (Int, Int)] =
for {
_ <- IO.foreach(inputs)(updateMachine)
machine <- ref.get
} yield (machine.coins, machine.candies)
…
}

Candy machine
def updateMachine(input: Input): IO[Nothing, Machine] =
refM.updateSome { machine =>
(input, machine) match {
case (Coin, Machine(true, candies, coins)) =>
Machine(false, candies, coins + 1)
case (Turn, Machine(false, candies, c)) =>
Machine(true, candies - 1, c)
}

Candy machine
case class System (refM: Ref[Machine]) {
def simulate(inputs: List[Input]): IO[Nothing, (Int, Int)] =
for {
_ <- IO.foreach(inputs)(updateMachine)
machine <- refM.get
} yield (machine.coins, machine.candies)
…
}

Schedule
Schedule is an immutable value that describes
an effectful schedule, that decides to halt or
continue after some delay.

Schedule
● repeat actions
● retry actions in event of errors

Schedule
trait IO[E, A] {
def repeat[B](schedule: Schedule[A, B]): IO[E, B]
}
val refresh: IO[Nothing, Int] =
loadPage.repeat(Schedule.fixed(5.seconds))

Schedule
trait IO[E, A] {
def retry[B](policy: Schedule[E, B]): IO[E, A]
}
val request: IO[HttpError, Request] =
handleRequest.retry(Schedule.doWhile(_.code == 503))

Queue
Queue is an asynchronous queue which allows to add and
remove elements in First In First Out manner.
...
V6
V5
V4
V3
V2
V1
offer* take*
Producers Consumers

Queue
trait Queue[A] {
def take: IO[Nothing, A]
def takeAll: IO[Nothing, List[A]]
def takeUpTo(max: Int): IO[Nothing, List[A]]
def offer(a: A): IO[Nothing, Boolean]
def offerAll(as: Iterable[A]): IO[Nothing, Boolean]
}
object Queue {
def bounded[A](capacity: Int): IO[Nothing, Queue[A]]
def unbounded[A]: IO[Nothing, Queue[A]]
def sliding[A](capacity: Int): IO[Nothing, Queue[A]]
def dropping[A](capacity: Int): IO[Nothing, Queue[A]]
}

Backpressure
for {
queue <- Queue.unbounded[String]
v1 <- queue.take.fork
take
take
Consumers

Backpressure
take
take
Consumers
for {
_ <- queue.offer("hello").fork
“hello”
Producers

Backpressure
take
take
Consumers
“hello”
for {
_ <- queue.offer("bye").fork
Producers
“bye”

Backpressure
take
take
Consumers
“bye”
“hello”
for {
Producers

Backpressure
take
Consumers
for {
Producers
“bye”
“hello”

Backpressure
Consumers
for {
} yield ()
Producers
“hello”
“bye”

Bounded Queue
A bounded Queue with capacity = 3
for {
queue <- Queue.bounded[String](3)

Bounded Queue
“b”
“c”
“a”
“d”
“b”
“c”
Producers
for {
_ <- queue.offer("a").fork
_ <- queue.offer("b").fork
_ <- queue.offer("c").fork
_ <- queue.offer("d").fork

Bounded Queue
“c”
“b”
“a”
offer(“d”)
Producers
for {

Bounded Queue
offer(“d”)
ConsumersProducers
for {
“c”
“b”
“a”

Bounded Queue
“c”
“b”
offer(“d”)
Consumers
“a”
Producers
for {

Bounded Queue
“d”
“c”
“b”
ConsumersProducers
for {
} yield ()

Sliding Queue
for {
queue <- Queue.sliding[String](3)
_ <- queue.offer("A") //(1)
} yield ()

Sliding Queue
for {
_ <- queue.offer("B") //(2)
} yield ()

Sliding Queue
for {
_ <- queue.offer("C") //(3)
} yield ()

Sliding Queue
for {
_ <- queue.offer("D") //(4)
} yield ()

Dropping Queue
for {
queue <- Queue.dropping[String](3)
} yield ()

Dropping Queue
for {
} yield ()

Shutdown Queue
for {
_ <- queue.offer("A").forever.fork
_ <- queue.take.forever.fork
_ <- queue.shutdown
} yield ()

104
Include ZIO in your project by adding the following to your
build.sbt
libraryDependencies += "org.scalaz" %% "scalaz-zio" % "1.0-RC1"

https://scalaz.github.io/scalaz-zio/

thanks!
Any questions?
You can find us at
@WiemZin
@Oleksandra_A

ZIO: Powerful and Principled Functional Programming in Scala

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to ZIO: Powerful and Principled Functional Programming in Scala

Similar to ZIO: Powerful and Principled Functional Programming in Scala (20)

More from Wiem Zine Elabidine

More from Wiem Zine Elabidine (6)

Recently uploaded

Recently uploaded (20)

ZIO: Powerful and Principled Functional Programming in Scala

Editor's Notes