The document discusses functional programming concepts using ZIO, a Scala library that supports asynchronous and concurrent programming. Key ideas include pure functions, immutability, functional effects, error management, and resource management, along with practical application examples. It emphasizes the importance of composing functions and managing dependencies effectively within a purely functional programming paradigm.

1. ZIO from
Home
Wiem Zine Elabidine
@WiemZin
Stay Safe

2. Functional Effects

3. Functional Programming
Pure functions
Referential
transparency.
Composability
Combine functions
together to build
new data.
Immutability
Values couldn’t be
changed.
Data & Functionality
Pass data through
functions to
change its
behaviors.

4. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic

5. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def toInt(str: String): Try[Int] =
Try(str.toInt)

6. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def toInt(str: String): Try[Int] =
Try(str.toInt)
toInt("One")

7. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def toInt(str: String): Try[Int] =
Try(str.toInt)
toInt("One")
Failure(java.lang.NumberFormatException: For input string: "One")

8. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def nextDay(day: DayOfWeek): String =
day.plus(1) .toString
assert(nextDay(THURSDAY)))(equalTo("FRIDAY"))

9. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def nextDay(day: DayOfWeek): String =
day.plus(1) .toString
assert(nextDay(THURSDAY)))(equalTo("FRIDAY"))

10. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic
def add(pasta: Pasta, sauce: Sauce,
water: Water): Cooked[Pasta] = {
val p = water.boil.map(_.put(pasta))
p.addSauce(sauce)
}

11. Stay home safe and
use what you have
No Side effects
Pure Function
Trust your types
Total
Test your functions
Deterministic

12. Effects are useful
❏ handle events
❏ Send messages
❏ read from the DataBase
❏ persist information
❏ print out the result
❏ retry in event of errors
❏ send result to other
services
❏ ...
Real World Applications

13. Abstract your programs!
Describe everything in
immutable data type!
Functional Effects
Effects as values?

14. Functional Effects
case class IO[A](unsafeRun: () => A) {
def map[B](f: A => B): IO[B] = ???
def flatMap[B](f: A => IO[B]): IO[B] = ???
}
object IO {
def effect[A](a: => A): IO[A] = new IO[A](() => a)
}

15. Functional Program
val program: IO[Unit] = for {
event <- IO.effect(handleEvent)
user <- IO.effect(getUser(event.userId))
_ <- IO.effect(logInfo(user))
...
} yield ()

16. Functional Program
val program: IO[Unit] = for {
event <- IO.effect(handleEvent)
user <- IO.effect(getUser(event.userId))
_ <- IO.effect(logInfo(user))
...
} yield ()
program.unsafeRun()

17. Execution
Just do it!
Description
Make a plan A - Z
Be prepared!

18. ● Control over all type of interactions
● Testability
● Refactoring
Why Functional Effects?

19. Functional Effects
case class IO[A](unsafeRun: () => A) {
def map[B](f: A => B): IO[B] = ???
def flatMap[B](f: A => IO[B]): IO[B] = ???
}
object IO {
def effect[A](a: => A): IO[A] = new IO[A](() => a)
}

20. ZIO
Zero dependency Scala library for asynchronous and concurrent
programming using purely functional code.

21. Functional Effects in ZIO
ZIO[R, E, A]
Description of a program
R
E A
Dependencies
Error Success

22. Functional Effects in ZIO
RIO[R, A]
Description of a program
R
Throwable A
Dependencies
Error Success

23. Functional Effects in ZIO
URIO[R, A]
Description of a program
R
A
Dependencies
Success

24. Functional Effects in ZIO
Task[A]
Description of a program
Throwable A
Error Success

25. Functional Effects in ZIO
IO[E, A]
Description of a program
E A
Error Success

26. Functional Effects in ZIO
UIO[A]
Description of a program
A
Success

27. Run Effects
object Main extends zio.App {
override def run(args: List[String]): IO[Nothing, Int] =
program.fold(_ => 1, _ => 0)
}
OR
object Main {
Runtime.default.unsafeRun(program)
}

28. Error
Management

29. Error Management
Throwable
def divideM(a: Int, b: Int): Task[Int] =
Task(divide(a, b))
Task[Int]
Throwable Int

30. Error Management
Throwable
val throwException: Task[Nothing] =
Task(throw new Exception("sorry"))
Task[Nothing]
Throwable

31. Error Management
String
val failedIO: IO[String, Nothing] = IO.fail("sorry again")
IO[String, Nothing]
String

32. Error Management
Customized Errors
sealed trait Error
object Error {
case class UserNotFound(id: UserId) extends Error
case class InternalServer(t: Throwable) extends Error
...
}
val program: IO[Error, Unit] = ???

33. Error Management
Customized Errors
val program: IO[Error, Unit] =
for {
userId <- requestListener // IO[InternalServer, UserId]
user <- getUser(userId) // IO[UserNotFound, User]
_ <- logInfo(user) // IO[ Nothing, Unit]
_ <- sendResponse(user) // IO[InternalServer, Unit]
} yield ()

34. Error Management
The state of the program
val program: IO[Error, Unit] = ???
val programState: IO[Nothing, Exit[Error, Unit]] = program.run

35. Error Management
Exit[E, A]
Success[A]Failure[E]

36. Error Management
Exit[E, A]
Success[A]Failure[E]

37. Error Management
Exit[E, A]
Success[A]Failure[E]
Cause[E]

38. Cause[E]
Die
Expected Error
Unexpected Error, Exception
Fail[E]
Interrupted effect
Interrupt

39. Many causes?
Both(left, right)
Both(Fail(e1),
Then(Both(Fail(e2), Die(t)), Interrupt)
Then(left, right)

40. Example: Cause.Both
IO.fail("error1")
.zipPar(
IO.succeed(throw new Exception("💣 surprise!"))
)

41. Example: Cause.Both
IO.fail("error1") // Cause.Fail("error1")
.zipPar(
IO.succeed(throw new Exception("💣 surprise!"))
)

42. Example: Cause.Both
IO.fail("error1") // Cause.Fail("error1")
.zipPar(
IO.succeed(throw new Exception("💣 surprise!")) // Cause.Die(...💣)
)

43. Example: Cause.Both
IO.fail("error1") // Cause.Fail("error1")
.zipPar(
IO.succeed(throw new Exception("💣 surprise!")) // Cause.Die(...💣)
)
⇒ Both(Cause.Fail("error1"), Cause.Die(java.lang.Exception: 💣 surprise!)))

44. Example: Cause.Then
IO.fail("error").ensuring(IO.die(new Exception("Don't try this at Home")))

45. Example: Cause.Then
IO.fail("error").ensuring(IO.die(new Exception("Don't try this at Home")))
Fail("error")

46. Example: Cause.Then
IO.fail("error").ensuring(IO.die(new Exception("Don't try this at Home")))
Fail("error") Die(java.lang.Exception Don’t try this at Home)

47. Example: Cause.Then
IO.fail("error").ensuring(IO.die(new Exception("Don't try this at Home")))
Fail("error") Die(java.lang.Exception Don’t try this at Home)
⇒ Then(Cause.Fail("error"), Cause.Die(java.lang.Exception: Don’t try this at Home))

48. Error Management
Expose all causes:
def divide(a: Int, b: Int): IO[Cause[Throwable], Int] =
Task(a / b).sandbox

49. Error Management
Catch Errors:
def divide(a: Int, b: Int): Task[Int] =
Task(a / b)
.catchSome{
case _: ArithmeticException => UIO(0)
}

50. Error Management
Peek at the errors:
def divide(a: Int, b: Int): Task[Int] =
Task(a / b)
.tapError{
error => UIO(println(s"failed with: $e"))
}

51. Error Management
Fallback:
val io1: IO[Error, Int] = ???
val io2: IO[String, Int] = ???
val result: IO[String, Int] = io1.orElse(io2)

52. Error Management
Fallback:
val loginUser: IO[Error, Profile] = ???
val loginAnonymous: IO[Throwable, LimitedProfile] = ???
val result: IO[Throwable, Either[Profile, LimitedProfile]] =
loginUser.orElseEither(loginAnonymous)

53. Error Management
Recover:
def divide(a: Int, b: Int): UIO[Int] =
Task(a / b).foldM(_ => UIO(0), n => UIO(n))

54. Error Management
Crash it:
def divide(a: Int, b: Int): UIO[Int] =
Task(a / b).orDie

55. Error Management
Make defects as expected errors:
val io: IO[String, Nothing] =
IO.succeed(throw new Exception("💣"))
.unrefine(e => s"The error is: $e")

56. Error Management
What about fatal Errors?

57. Error Management
def simpleName[A](c: Class[A]) = c.getSimpleName
object Example
Task(simpleName(Example.getClass))

58. Error Management
def simpleName[A](c: Class[A]) = c.getSimpleName
object Example
Task(simpleName(Example.getClass))
[error] java.lang.InternalError: Malformed class name
[error] at java.lang.Class.getSimpleName(Class.java:1330)

59. Error Management
object Main extends zio.App {
override val platform: Platform =
Platform.default.withFatal (_ => false)
override def run(args: List[String]): ZIO[zio.ZEnv, Nothing, Int] = {
Task(simpleName(Example.getClass)).fold(_ =>1, _ => 0)
}
}

60. Error Management
override val platform: Platform = new Platform {
val executor = Executor.makeDefault(2)
val tracing = Tracing.disabled
def fatal(t: Throwable): Boolean =
!t.isInstanceOf[InternalError] && t.isInstanceOf[VirtualMachineError]
def reportFatal(t: Throwable): Nothing = {
t.printStackTrace()
throw t
}
def reportFailure(cause: Cause[Any]): Unit = {
if (cause.died)
System.err.println(cause.prettyPrint)
}
...
}

61. Build concurrent
programs

62. ZIO Fibers
Fibers are lightweight mechanism of concurrency.
OS Thread
ZIO Fiber
Task1 Task2 Task3 ... ..

63. How ZIO runs Effects?
ZIO[R, E, A]

64. How ZIO runs Effects?
ZIO[R, E, A]
R => IO[E, A]

65. How ZIO runs Effects?
ZIO[R, E, A]
R => IO[E, A]

66. How ZIO runs Effects?
ZIO[R, E, A]
R => IO[E, A]

67. How ZIO runs Effects?
IO[E, A]

68. How ZIO runs Effects?
IO[E, A]
Fiber[E, A]
unsafeRun

69. How ZIO runs Effects?
IO[E, A]
Fiber[E, A]
unsafeRun

70. How ZIO runs Effects?
IO[E, A]
Fiber[E, A]
unsafeRun

71. How ZIO runs concurrent Effects?
IO[E, A]
Fiber[E, A]
unsafeRun
IO[Nothing,Fiber[E, A]]
fork

72. How ZIO runs concurrent Effects?
IO[E, A]
Fiber[E, A]
unsafeRun
IO[Nothing,Fiber[E, A]]
fork

73. How ZIO runs concurrent Effects?
IO[E, A]
Fiber[E, A]
unsafeRun
IO[Nothing,Fiber[E, A]]
fork
Fiber[E, A]
unsafeRun

74. How ZIO runs concurrent Effects?
IO[E, A]
Fiber[E, A]
unsafeRun
IO[Nothing,Fiber[E, A]]
fork
Fiber[E, A]
unsafeRun

75. Concurrent Tasks
trait ZIO[R, E, A] {
def race(that: ZIO[R, E, A]): ZIO[R, E, A]
def raceAll(ios: Iterable[ZIO[R, E, A]]): ZIO[R, E, A]
def zipPar(that: ZIO[R, E, B]): ZIO[R, E, (A, B)]
def on(ec: ExecutionContext): ZIO[R, E, A]
...
}
object ZIO {
def foreachPar(as: Iterable[A])(fn: A => ZIO[R, E, B]): ZIO[R, E, List[B]]
...
}

76. Concurrent Tasks
def getUserInfo(id: Id): Task[(User, Profile)] =
fetchUser(id).zipPar(fetchProfile(id))
Task 1 Task 2
(User, Profile)

77. Example
case class IlForno(queue: Queue[Request], currentIngredients: Ref[Ingredients]) {
def handleRequests(p: Promise[Nothing, Unit]): ZIO[Clock, MissingIngredient, Unit] =
(for {
request <- queue.take
rest <- currentIngredients.update(preparePizza(request, _))
_ <- evaluate(rest)
} yield ())
.tapError(_ => p.succeed(()))
.repeat(Schedule.duration(8.hours) && Schedule.spaced(10.minutes))
.unit
val listenRequests: IO[Error, Unit] = ???
}

78. val program: ZIO[Clock, Error, Unit] = for {
ilForno <- IlForno(initialIngredient)
f1 <- ilForno.listenRequests.fork
p <- Promise.make[Nothing, Unit]
f2 <- ilForno.handleRequests(p).fork
_ <- p.await
_ <- f1.interrupt.zipPar(f2.interrupt)
} yield ()
Example

79. Example
val program: ZIO[Clock, Error, Unit] = for {
ilForno <- IlForno(initialIngredient)
f1 <- ilForno.listenRequests.fork
p <- Promise.make[Nothing, Unit]
f2 <- ilForno.handleRequests(p).fork
_ <- p.await
_ <- f1.interrupt.zipPar(f2.interrupt)
} yield ()

80. Example
val program: ZIO[Clock, Error, Unit] = for {
ilForno <- IlForno(initialIngredient)
f1 <- ilForno.listenRequests.fork
p <- Promise.make[Nothing, Unit]
f2 <- ilForno.handleRequests(p).fork
_ <- p.await
_ <- f1.interrupt.zipPar(f2.interrupt)
} yield ()

81. Example
val program: ZIO[Clock, Error, Unit] = for {
ilForno <- IlForno(initialIngredient)
f1 <- ilForno.listenRequests.fork
p <- Promise.make[Nothing, Unit]
f2 <- ilForno.handleRequests(p).fork
_ <- p.await
_ <- f1.interrupt.zipPar(f2.interrupt)
} yield ()

82. Resource
Management

83. Resource Management
File Connection
Open / close / use = Acquire / release / use
Database Clients

84. Resource Management
IO.effect(startApp)
.ensuring(
console.putStr("Shutdown ..."))
ensuring
01

85. Resource Management
IO.effect(startApp)
.ensuring(
console.putStr("Shutdown ..."))
createClient(config)
.bracket(_.close)(c =>
processEvents(c))
ensuring bracket
01 02

86. Resource Management
IO.effect(startApp)
.ensuring(
console.putStr("Shutdown ..."))
ensuring
val resource =
Managed.make(openFile(file))(_.close)
...
resource.use(computeLines)
Managementbracket
01 0302
createClient(config)
.bracket(_.close)(c =>
processEvents(c))

87. Resource Management
● You can use the methods provided by the dependencies in your
program.
● once you provide a layer or an environment, the implementation
will be acquired and used then released at the end.
ZIO Environment & ZLayer[R, E, A]

88. ZIO
is Awesome

89. WrapUp
documentation
https://github.com/zio/zio
zio.dev
ZIO projects
Blog post
https://medium.com/@wiemzin

90. CREDITS: This presentation template was
created by Slidesgo, including icons by Flaticon,
and infographics & images by Freepik
THANKS
Follow me: @WiemZin
Please keep this slide for attribution