Kyo - Functional Scala 2023

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.

Transcript

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