Kyo - Functional Scala 2023.pdf

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

How can I build
solutions that are

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

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

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

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

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

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

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

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

Functional
Programming is
great

Functional
Programming is
great (but terrible)

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

Innovation
begins with
broken rules

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]

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?

Let’s break
the rules
again :)

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

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

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

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

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

Leveraging
Scala’s advanced
type system

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

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

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

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

Original Design
Implicit conversions
from/to T > Any and T

After Scala 2 support

type >[+T, -S] >: T

type >[+T, -S] >: T
Any type T is a subclass of T > Any

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

Effect Widening

Effect Widening
val b: Int > Options = a

Effect Widening
val c: Int > (Options & Tries) = b

Effect Widening
val c: Int > (Options & Tries) = b
val d: Int > (Options & Tries) = 42

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

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

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

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

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

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

Kyo - Functional Scala 2023.pdf

Requests: HTTP Client via Sttp

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

https://tinyurl.com/kyo-benchs

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

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

High-performance
asynchronous
primitives

Low-overhead
Fibers
(only 32B
each!)

Caprese
Kyo delivers
Caprese’s
key promises

Caprese
Kyo delivers
Caprese’s
key promises
without language
changes

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

Caprese
Kyo delivers Caprese’s
key promises
without language
changes,
effects
and next-level
performance

Caprese
key promises
without language changes,
effects
and next-level
performance
in Scala 2, 3, and JS

Caprese
key promises
without language changes,
effects
and next-level performance
in Scala 2, 3, and JS
today

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

Kyo - Functional Scala 2023.pdf

More Related Content

What's hot (20)

Similar to Kyo - Functional Scala 2023.pdf (20)

Recently uploaded (20)

Kyo - Functional Scala 2023.pdf