ZIO Queue

Queue
Wiem Zine Elabidine
Milan Scala Group

Wrap up
Tour of ZIO
Queue
Intro

First point
John De Goes revealed the high performance of Scalaz8 Effect.

The Scalaz8 effect is moved to a new
library Scalaz-zio with zero dependencies.
Good news!

What is ZIO?
ZIO provides purely functional data
structures with an abstraction for the
effectful programs using monads.

Effectful program
● Interaction with the real World
● Hard to reason about
● Hard to test
● Refactoring
● Programming without effects is useless

Properties of pure functions
Non-pure functions
def parseInt(s: String): Int = s.toInt
def addOne(x: Int): Int = Random.nextInt(x) + 1
def buyCoffee(cc: CreditCard): Coffee = {
val cup = new Coffee()
p.charge(cc, cup.price)
cup
}

Non-pure functions
cup
}
parseInt("Hello!")
[error] java.lang.NumberFormatException:
For input string: "Hello!"
NOT TOTAL!

Non-pure functions
cup
}
addOne(10)
> 4
addOne(10)
> 6
addOne(10)
> 2
NON DETERMINISTIC!

Non-pure functions
cup
}
SIDE EFFECT!

Non-pure functions
cup
}
def program(): = { }

Non-pure functions
cup
}
Pure functions
def parseInt(s: String): Option[Int] =
Try(s.toInt).toOption
def addOne(x: Int): Int = x + 1
def buyCoffee(cc: CreditCard): (Coffee, Charge) = {
(cup, Charge(cc, cup.price))
}
def program(): = { }

Pure functions
def parseInt(s: String): Option[Int] =
Try(s.toInt).toOption
def addOne(x: Int): Int = x + 1
def buyCoffee(cc: CreditCard): (Coffee, Charge) =
{
(cup, Charge(cc, cup.price))
}
Non-pure functions
cup
}
def program(): = { } def program(): = { }

● Total
● Deterministic
● Free of side effects

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

What is IO[E, A] ?
parseInt("hello") //fails with NumberFormatExceptionIO.syncException(parseInt(str))

What is IO?
parseInt("1")IO.syncException(parseInt(str))

What is IO[E, A] ?
println("Hello!")IO.sync(println("Hello!")

What is IO[E, A] ?
throw new Exception("error")IO.fail(new Exception("error"))

What is IO[E, A] ?
while(true) {}IO.never

IO[E, A] structure
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 now[A](a: A): IO[Nothing, A] = ???
...
}
IO[E, A]

IO Effects
IO describes the following effects:
● Pure Values
val number: Int= 1
val number: IO[Nothing, Int] = IO.now(1)

IO Effects
● Pure Values
● Synchronous Effect
println("hello")
val putStrLn: IO[Nothing, Unit] =
IO.sync(println("hello"))

IO Effects
● Pure Values
parseInt("hello")
val toInt: IO[Throwable, Int] =
IO.syncThrowable(parseInt("hello"))

IO Effects
● Pure Values
parseInt("hello")
val toInt: IO[Exception, Int] =
IO.syncException(parseInt("hello"))

IO Effects
● Pure Values
parseInt("hello")
val toInt: IO[String, Int] =
IO.syncCatch(parseInt("hello")){
case e: NumberFormatException => "oh no!"
}

IO Effects
● Pure Values
● Asynchronous Effects
Future(4)
IO.async[Nothing, Int](_(Completed(4)))

IO Effects
● Pure Values
● Concurrent Effects
val hello = new Thread(new Runnable {
def run() {
while (true) {
println("hello world")
}
}
})
for {
f <- IO.sync(println("hello world")).fork
_ <- f.join
} yield ()

IO Effects
● Pure Values
val hello = new Thread(new Runnable {
def run() {
while (true) {
println("hello world")
}
}
})
for {
f <- IO.sync(println("hello world")).forever.fork
_ <- f.interrupt
} yield ()

IO Effects
● Pure Values
● Resource Effects
val f: File = openFile()
try {
compute(f)
}
finally {
closeFile(f) //Unit
}
IO.bracket[Error, File, Unit](openFile())
(f => closeFile(f))(f => compute(f))

Usage of IO
In ZIO, every type has specific
features to solve different problems.
Each type is wrapped inside an IO.
Promise[E, A]
Ref[A]
Queue[A]
IO[E, A]

RTS: IO runtime system
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.sync(println("Hello")))

Ref
Ref is the equivalent of `var`
Ref has an AtomicReference to apply the
atomic operations on it.

Ref
Ref[A]
object Ref {
def apply[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 modify[B](f: A => (B, A)): IO[Nothing, B]
}

Example
for {
counter <- Ref(0)
v <- counter.update(_ + 1)
} yield v
for {
counter <- Ref(0)
v <- counter.modify {
prev =>
val newValue = prev + 1
(s"previous value: $prev, next value is: $newValue", newValue)
}
_ <- IO.sync(println(v))
} yield ()

Promise
A Promise is an asynchronous variable that
can be set only once.

Promise
`error`: fails the promise with the specified error, which will be
propagated to all fibers waiting on the value of promise.

Promise
`complete`: completes the promise with the specified value.

Promise
By default the state of Promise is Pending, once it fails or completes
the state changes to Done.
`done`: completes the promise with the specified result.

Promise
trait Promise[E, A] {
def get: IO[E, A]
def complete(a: A): IO[Nothing, Boolean]
def error(e: E): IO[Nothing, Boolean]
def interrupt(t: Throwable): IO[Nothing, Boolean]
def done(r: ExitResult[E, A]): IO[Nothing, Boolean]
}
Promise[E, A]
object Promise {
def make[E, A]: IO[Nothing, Promise[E, A]] = ???
}

Promise: Example
Get an alert for your friends’s
birthday, as follow up reminder to
offer the appropriate “happy
birthday” greeting.
🎂

Promise: Example
(for {
p <- Promise.make[Nothing, String]
_ <- p.complete(s"Your reminder for ${friend.name} birthday")
.delay(minus(LocalDate.now, friend.birthday))
.fork
msg <- p.get
} yield sendAlert(msg)).fork
20.12.2018

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*
Queue
Producers Consumers

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]]
}
Queue[A]
Queue

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

Takers
take
take
Consumers
for {

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

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

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

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

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

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

Back pressure
“c”
“b”
“a”
offer(“d”)
Producers
for {

Back pressure
take
offer(“d”)
ConsumersProducers
for {
“c”
“b”
“a”

Back pressure
“c”
“b”
offer(“d”)
Consumers
“a”
Producers
for {

Back pressure
“d”
“c”
“b”
ConsumersProducers
for {
} yield ()

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

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

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

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

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

Dropping
for {
} yield ()

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

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

Wrap Up
github.com/scalaz/scalaz-zio

Wrap Up
https://gitter.im/scalaz/scalaz-zio/
https://javadoc.io/doc/org.scalaz/scalaz-zio_2.12/0.5.1
https://scalaz.github.io/scalaz-zio/

ZIO Queue

More Related Content

What's hot

Similar to ZIO Queue

Recently uploaded

ZIO Queue