Kyo is a next-generation effect system that introduces an approach based on algebraic effects to deliver straightforward APIs in the pure Functional Programming paradigm. Unlike similar solutions, Kyo achieves this without inundating developers with esoteric concepts from Category Theory or using cryptic symbolic operators. This results in a development experience that is both intuitive and robust. Kyo generalizes the innovative effect rotation mechanism introduced by ZIO. While ZIO restricts effects to two channels, namely dependency injection and short-circuiting, Kyo allows for an arbitrary number of effectful channels. This enhancement offers developers greater flexibility in effect management and simplifies Kyo's internal codebase through more principled design patterns. In addition to this novel approach to effect handling, Kyo provides seamless direct syntax inspired by Monadless and a comprehensive set of built-in effects like Aborts for short-circuiting, Envs for dependency injection, and Fibers for green threads with fine-grained uncooperative preemption. After over two years in development, the first public release of the project will be made during Functional Scala 2023. Attendees will also be treated to benchmark results that showcase Kyo's unparalleled performance.

1. Releasing Kyo:
When Performance Meets Elegance In Scala
Flavio Brasil
Functional Scala 2023

2. How can I build
solutions that are

3. ●Simple
●Safe
●Fast
How can I build
solutions that are
?

4. Activate
My first open
source project
https://github.com/fwbrasil/activate

5. Bond
Type-level
validation
https://github.com/fwbrasil/bond

6. Clump: Batching
https://github.com/getclump/clump
Future: High-perf futures
https://github.com/traneio/future
Arrows: Monadic staging
https://github.com/traneio/arrows
NDBC: Async DB drivers
https://github.com/traneio/ndbc

7. Quill
Compile-time
Language
Integrated Queries
https://github.com/zio/zio-quill

8. Monadless
Syntactic sugar
for monads
https://github.com/monadless/monadless

9. When your hobby
becomes your
worry …
It’s time for a break!

10. A decade working on
large-scale systems
● SoundCloud, Twitter, Nubank
● Delivered major performance
optimizations for Finagle, Twitter
Future, Stitch, Graal, Clojure
● Saw hundreds of crashes
Scala ♥ Graal
ScalaMatsuri 2019
https://youtu.be/a6dK3eXhO7k?si=T775S1sKFu5B4wSf

11. Functional
Programming is
great

12. Functional
Programming is
great (but terrible)

13. Interpretation
overhead
User-level interpreted language
Highly dynamic execution
High allocation rate

14. Code complexity

15. Innovation
begins with
broken rules

16. ZIO[R, E, A]

17. ZIO[R, E, A]
type IO[+E, +A] = ZIO[Any, E, A]
type Task[+A] = ZIO[Any, Throwable, A]
type RIO[-R, +A] = ZIO[R, Throwable, A]
type UIO[+A] = ZIO[Any, Nothing, A]
type URIO[-R, +A] = ZIO[R, Nothing, A]

18. ZIO[R, E, A]
Do we really need a fixed arity?
Why assume the computation uses IO and Async?
Why only dependency injection and short-circuiting?
What if we could express an unbounded number of effects?

19. Let’s break
the rules
again :)

20. ZIO[R, E, A]

21. A > (R & E)

22. A > (Envs[R] & Aborts[E])

23. A > Aborts[E]

24. A > Any

25. A > Any
A pure value 😱

26. A > (Envs[Database] & Aborts[DBException])

27. A > (Envs[Database] & Aborts[DBException] & IOs)

28. type Databases = Envs[Database] & Aborts[DBException] & IOs
A > Databases

29. type Caches = Envs[Cache] & IOs
type Databases = Envs[Database] & Aborts[DBException] & IOs
A > (Databases & Caches)

30. type Caches = Envs[Cache] & IOs
type Databases = Envs[Database] & Aborts[DBException] & Caches
A > Databases

31. Leveraging
Scala’s advanced
type system

32. A > (Envs[Database] & Aborts[DBException] & IOs)

33. A > (Aborts[DBException] & Envs[Database] & IOs)

34. A > (Aborts[DBException] & IOs & Envs[Database])
Unordered Pending Effects

35. opaque type >[+T, -S]
Original Design

36. opaque type >[+T, -S] = T | Kyo[_, _, _, T, S]
Original Design

37. opaque type >[+T, -S] = T | Kyo[_, _, _, T, S]
Original Design
Implicit conversions
from/to T > Any and T

38. opaque type >[+T, -S] = T | Kyo[_, _, _, T, S]
After Scala 2 support

39. type >[+T, -S] >: T
After Scala 2 support

40. type >[+T, -S] >: T
After Scala 2 support
Any type T is a subclass of T > Any

41. type >[+T, -S] >: T
After Scala 2 support
Any type T is a subclass of T > Any
val a: Int > Any = 1
val b: Int = a.pure

42. Effect Widening
val a: Int > Any = 1

43. Effect Widening
val a: Int > Any = 1
val b: Int > Options = a

44. Effect Widening
val a: Int > Any = 1
val b: Int > Options = a
val c: Int > (Options & Tries) = b

45. Effect Widening
val a: Int > Any = 1
val b: Int > Options = a
val c: Int > (Options & Tries) = b
val d: Int > (Options & Tries) = 42

46. def example1(v: Int > (Options & Tries)) =
v.map(_ + 1)
Fluent APIs

47. def example1(v: Int > (Options & Tries)) =
v.map(_ + 1)
def example2(v: Int > Tries) =
example1(v)
Fluent APIs

48. Fluent APIs
def example1(v: Int > (Options & Tries)) =
v.map(_ + 1)
def example2(v: Int > Tries) =
example1(v)
def example3 = example1(42)

49. There is no
flatMap
(or map depending
on how you see it)

50. def example(
a: Int > Options,
b: Int > Tries
): Int > (Options & Tries) =
a.flatMap(v => b.map(_ + v))

51. def example(
a: Int > Options,
b: Int > Tries
): Int > (Options & Tries) =
a.map(v => b.map(_ + v))

52. Direct
syntax
support

56. Quick
effects
rundown

57. Envs: Dependency Injection

58. Envs: Dependency Injection

59. Aborts: Short Circuiting

60. Aborts: Short Circuiting

61. Resources: Resource Safety

62. Lists: Exploratory Branching

63. Lists: Exploratory Branching

64. Fibers: Green Threads

65. Fibers: Green Threads

66. Requests: HTTP Client via Sttp

67. Requests: HTTP Client via Sttp

68. Locals Scoped Values
Aspects Aspect-Oriented Programming
Options Optional Values
Tries Exception Handling
Consoles Console Interaction
Clocks Time Management
Randoms Random Values
Loggers Logging
Stats Observability
Queues Concurrent Queuing
Channels Backpressured Communication
Hubs Broadcasting with Backpressure
Meters Computational Limits
Timers Scheduled Execution
Latches Fiber Coordination
Atomics Concurrent State
Adders Concurrent Accumulation
Caches Memoized Functions via Caffeine

69. Unparalleled
performance

70. https://tinyurl.com/kyo-benchs

71. Targets
Kyo, Cats-effect, ZIO, Ox
Data
Throughput, Allocation, Profiling
Environment
Github Large Runner
8 cores, 32 GB
Ubuntu 22.04
Source code
https://github.com/getkyo/kyo/tree/main/kyo-bench/src/main/scala/kyo/bench
https://tinyurl.com/kyo-benchs

72. Kyo’s
throughput is
249% higher
than the best contender
(average across benchmarks)

73. Overhead-free abstraction

74. Overhead-free abstraction

75. Overhead-free abstraction

76. High-performance
asynchronous
primitives

77. High-performance
asynchronous
primitives

78. High-performance
asynchronous
primitives

79. Low-overhead
Fibers
(only 32B
each!)

80. Low-overhead
Fibers
(only 32B
each!)

81. Low-overhead
Fibers
(only 32B
each!)

82. Blazing-fast channels

83. Blazing-fast channels

84. Blazing-fast channels

85. How about
Caprese?

86. Caprese
Kyo delivers
Caprese’s
key promises

87. Caprese
Kyo delivers
Caprese’s
key promises
without language
changes

88. Caprese
Kyo delivers
Caprese’s
key promises
without language
changes,
with a complete set of
effects

89. Caprese
Kyo delivers Caprese’s
key promises
without language
changes,
with a complete set of
effects
and next-level
performance

90. Caprese
Kyo delivers Caprese’s
key promises
without language changes,
with a complete set of
effects
and next-level
performance
in Scala 2, 3, and JS

91. Caprese
Kyo delivers Caprese’s
key promises
without language changes,
with a complete set of
effects
and next-level performance
in Scala 2, 3, and JS
today

92. CREDITS: This presentation template was created
by Slidesgo, and includes icons by Flaticon and
infographics & images by Freepik
Thanks!
Any questions?
https://getkyo.io
https://dev.to/fwbrasil
@fbrasisil