Beyond `flatMap`: Is Kyo the Future of Scala Effects? by Jonathan Winandy | Scalar 2026

Añadido: 2026-05-28

[00:00:03]Before we start, I have a quick question for you. Um, is have you touched a a monad in your life? Like, could you raise your hand?

[00:00:11]Okay.

[00:00:12]And I use Are you still using monads currently uh in the day-to-day?

[00:00:18]So, I would say most of you, okay.

[00:00:22]Interesting.

[00:00:24]>> [snorts] >> Um So, uh yeah, I am. Like, my name is Jonathan.

[00:00:29]And uh usually I present subject around data engineering and I My job is to find the right person to talk about something on Scala. So, I've been doing the organization of Scala IO for years.

[00:00:41]And recently I became a contributor to to ZIO and so I'm advocating for for ZIO. So, I'm spreading a bit >> [snorts] >> uh what can ZIO do.

[00:00:55]So, what is ZIO?

[00:00:56]Uh ZIO um in in a big sum up, it's pure functional programming. So, you have to get the idea. It's um tinted by the pure functional programming principle with data types, composition, uh concurrency.

[00:01:11]It has a performance objective. Like, you cannot release a a library nowadays that at least don't do as good as most most benchmark compared to the two major solution in the market, which are um ZIO and Cats Effect.

[00:01:27]It's competitive with Loom. Uh we we can talk about it. It it depends on the benchmark and some of us would say that actually don't even matter at the end uh because you the IO would matter.

[00:01:40]Like, not the scheduling of the IO.

[00:01:43]And it has a lot of tools and it connect with the ecosystem.

[00:01:47]It has direct syntax. It has uh complete compatibility with ZIO and Cats Effect.

[00:01:53]It has a HTTP uh tools, parsing, and you could also build your own tool inside Q.

[00:02:01]So, where did Q come from? It come from um sabbatical work of Flavio. And so, Flavio, we know Flavio from uh previous libraries in the Scala ecosystem, uh Quill, so the language integrated queries.

[00:02:14]I don't know if you if you remember like in in 2012, we started to have macros announced in Scala to do these kind of things in the language like like integrated queries like uh Link Q.

[00:02:26]And so, Quill is able to do that.

[00:02:28]Uh there is monad less, uh syntactic sugar for monad.

[00:02:33]And on on top of this sabbatical work, uh we have contributions from other that are that have contributed to other effect system like Adam, uh John, uh Jason Pickens, and Kit Langton.

[00:02:47]The core idea of Q is to move from vertical composition, so G of F of uh A of F of G to A um that uh has a pending S1 and S2, so that need the effect S1 and S2 and S2. And there is no order between those two.

[00:03:11]So, the plan for today is to have put on the short program in Q, um talk about the um the planning types, the on layers, uh explain a bit the suspension mechanism just a bit, um the comparison with uh ZIO and Cats Effect and also the outside. And then we can we can wrap that up.

[00:03:34]Okay. So, a short program in Q. To start with, you if you're using Scala actually, uh use a a recent version of Scala, so 3.7 currently.

[00:03:45]And you you use it as a dependency.

[00:03:49]You need when you work with Q to have extra compiler options. So, value discard, non-unit statement. You will find those compiler options for most of the monadic effect systems in Scala, as well as turning those warning into into errors. Um because that would lead to part of the program to be discarded if you if you don't do that.

[00:04:12]The latest version of Q is is 1.0 RC1, but we have a RC2 coming very soon.

[00:04:18]That is ready for Scala 3.8.

[00:04:23]And a complete program would be that.

[00:04:25]So, you have a couple of lines.

[00:04:28]In this case, it's in the direct syntax.

[00:04:31]So, you expect express a program as a value. So, it's the direct line for each line console.print line.now.

[00:04:38]So, it's the async await syntax.

[00:04:42]And then you wrap that up with it into a main, and that's it. So, you have a Q program.

[00:04:49]If we do it in the regular syntax, that would look like that.

[00:04:53]So, we could use combinators.

[00:04:55]But the essence of of it is you have a couple of lines. For each line, you are doing an effect or a computation. You chain them using and then. So, it's previous computation and then the following computation.

[00:05:10]And then you run that program.

[00:05:13]So, you follow like you you would be very similar to what you would do in uh ZIO and Cats Effect.

[00:05:22]So, a quick note about the direct block.

[00:05:25]Uh thanks to the work of Ruslan, uh we are able to have this direct syntax, which remove a lot of the uh syntax element when you need to work deep on the structure or to combine effects together.

[00:05:39]So, you are able to express a program as bit of an imperative style, but it it's a pure uh functional composition.

[00:05:47]And that works well in nested structure as well as you could define as as controls and and so on.

[00:05:54]So, that makes some of the programs uh more readable and and less like in the Falcon container or flat map style.

[00:06:04]Um however, it's completely optional.

[00:06:06]It's a it's a syntax on top of Q. And that's the part of Q um I'm mostly contributing to, like uh removing uh issues and improving ergonomics, which is uh so far done for now.

[00:06:21]So, the the question we we have to ask ourselves today is, does Q work with AI?

[00:06:30]So, currently, out of the box, it's not so bad.

[00:06:34]Uh the AI is not trained to work with Q, so Q is is a bit new for the for any uh frontier model.

[00:06:41]However, with a bit of context and a bit of example, uh it works fine. And since the inference is working in Q, the AI don't have to uh type for you. It could just infer the type and and that works.

[00:06:57]So, let's take a look at the building blocks. So, pending types and and less.

[00:07:02]So, the main building block of Q, what you see as a type, is A pending S.

[00:07:09]So, that mean A that is waiting for S to be resolved, so we have the value A.

[00:07:16]So, to give you comparison, if you have a single value A, that would be A uh pending any. So, pending is a contravariant, so any would be um the like you don't need anything.

[00:07:29]In the case of either try or try either, you would have A um in the context of abort. So, that mean that you have a piece of control flow, you need to manage um to uh manipulate the value A.

[00:07:44]So, you can directly manipulate A, so as you would do with monads, or you can manipulate the whole context.

[00:07:52]For future, you have async.

[00:07:54]And if you have a future of either, this is where I start to be interesting.

[00:07:58]You have async and a board of each.

[00:08:03]They are It's not one in the other. They are side by side.

[00:08:09]So, that's a value proposition like effect rotation.

[00:08:12]And the horizontal composition.

[00:08:15]And if you take a look at the a capture checking, you have a cancel would turn into a board of E.

[00:08:23]So, since you're having exposed to capabilities, we could define another operator it's just for this talk, but that will remove a lot of parentheses.

[00:08:32]Um, but it if that helps you with the bending gap or the domestic goose gap.

[00:08:41]So, once once we have these those values, so, um, for example, V A in in async and F, if you want to to work with V, you would just V.map F and that's it.

[00:08:57]As you would do with any monads.

[00:08:59]Um, if you have a G that is a a function from B to C in a board of string, uh, you just map as well.

[00:09:11]So, map and flat map in Q are the same.

[00:09:15]And they they collapse the bending set, the set of effects you need to resolve at the end.

[00:09:21]So, on the left side, you have async.

[00:09:24]On the right side, you have in in G a board of string, and then you concatenate and you put to the set of effects you need to resolve after.

[00:09:38]So, that a lot the the vertical composition and the and the lifting we need to do and undo um when we work with effect system and with effect systems.

[00:09:54]And then we have the handlers. So, when we have those values, look, A in the context of S1 and S2, we want to remove like those effects.

[00:10:03]And to remove those effects per effect, we have the concept of handler. So, in the case of abort, we want to remove abort, so that means that we have to manage the workflow.

[00:10:14]I mean the the control flow where you have errors and you have the value.

[00:10:18]You you transform your A into some other value that turn the effect into the value. In this case, it would be a result. It's like an either.

[00:10:27]And you may or may not introduce a new effect in the process.

[00:10:32]So, to give you an example, we have the program, so string in the context of abort error and async. And when we undo the abort part, we have a result of error string in the context of async.

[00:10:48]So, we add the effect at the pending set.

[00:10:51]And later in the program, we remove those effects using handlers.

[00:10:57]And handlers are composable, so you can choose the the type of handling you you want uh when you want to handle those those effects.

[00:11:09]So, async still pending at the end.

[00:11:13]But uh at least we in this case we manage all the the errors, so the the checked I mean the types exceptions or type errors and also the um untyped one when they are not uh panic.

[00:11:31]So, for var, we would have the same thing. So, var inc.

[00:11:35]So, we do the update. So, this function will take uh integer in the state, add plus one.

[00:11:42]We have a little function that show from int to string. And then we have this little program. So, it's inc and then inc.

[00:11:50]And then map the result to to show.

[00:11:54]And we have two uh handlers. The first one is we pass the value zero, and then we uh handle the the effects.

[00:12:04]So, we get back the value two.

[00:12:06]So, we inc twice.

[00:12:08]And we have another handler like run tuple, where we pass the value zero, but also get the state um of the var at the end.

[00:12:17]So, you have how many as many handlers as you want in your program, and you can compose them.

[00:12:22]Uh which is nice in in some cases.

[00:12:25]Uh you just want to uh handle the the state. And in in the other cases, you want to get the the last the remaining value.

[00:12:36]So, in the big picture, you compose your your programs in small parts.

[00:12:42]And you have the A and then all the effects you need about E var S async.

[00:12:50]You have the handlers one by one. So, in this case, we first handle the about, and then we handle the state.

[00:12:58]Uh it turns into this value. So, results EA in async. And then you pass that to the main, and you just run.

[00:13:09]So, you you stack your effects.

[00:13:11]Then you remove them.

[00:13:13]And then you run the remaining effect.

[00:13:15]Usually, it's async and async at the end of the program.

[00:13:23]So, the if we go a bit deeper on the building block, we have the concept of suspension. So, how that works is a queue composed with with a lot of suspensions.

[00:13:34]So, in the program, when you declare something like a var, that sets three, you create a suspension at this place in the program that will tag what kind of effect you have at this point.

[00:13:47]We'll [snorts] set the input. In in this case, the input is set three. So, that just um I will reset the state to the value three. And then the continuation, what you do with uh the rest of the program. And the job of the handler is to provide the logic to go from the input to the continuation.

[00:14:10]In the case of var, the logic is to um maintain a state, to update that state with uh the input, and then to continue the rest of the program with the last value of that state.

[00:14:25]And if we do with update, uh it it would be the same kind of suspension. Uh the tag would be uh var of int. The input would be update. And the continuation is what we do with um the uh rest of the suspension.

[00:14:42]So, the job of the handler is to connect the input and the continuation.

[00:14:48]And you can have the handler you you want in this case. So, the the program is stopped somehow. You just open a frame.

[00:14:56]And you have the input, the continuation, and you do what you need to do in between.

[00:15:01]Which is very composable at the end because you have could open frames, close them, and you want to make it as efficient as possible.

[00:15:10]So, there is a lot of inlining in the process.

[00:15:15]So, the principal effect you would see is var, emit, that produce a value like a log or part of a stream.

[00:15:25]About for the control flow.

[00:15:27]Environment to pass value to your context.

[00:15:31]So, that would be like your reader.

[00:15:34]A choice.

[00:15:36]Choice that is doing multi-shot.

[00:15:39]But, multi-shot is debatable. Like, do you really do we really need multi-shot?

[00:15:44]And the use case of multi-shot are usually very advanced. But, that's very good to actually test you have composing effects because if you pass a test that have choice in it, usually you have done things right.

[00:16:02]So, let's talk about the ecosystem.

[00:16:05]The interrupt with ZIO and Cats Effect.

[00:16:08]>> [snorts] >> So, if you go from ZIO to KIO, um you can translate your type directly back in KIO. And you have two modules.

[00:16:20]Um KIO ZIO and KIO scheduler ZIO, uh which is a ZIO runtime based on KIO.

[00:16:28]That's how it's done. So, you do the the interrupt on the value, and you can change the the scheduler to as the same scheduler in ZIO and KIO, and that and that works.

[00:16:40]So, the layers supported, there is a macro, and that stream time into a stream.

[00:16:45]But, you you see like the the the types in ZIO. So, you have three type parameters.

[00:16:51]And in KIO, you you can reduce and increase the pending set.

[00:17:00]So, uh you have as many as you want, and you can be more precise in some case. In in ZIO, you have to work with the ZIO type. In KIO, you don't If you don't need it is async, you you are not in async.

[00:17:17]From uh Cats Effect FS2 to Kio, uh you have the the same interoperability.

[00:17:25]So, you you have a better bi-directional interop on IO, and you could use Kio as a scheduler for Cats.

[00:17:35]And the the reason that everything is working with ZIO and Cats Effect is because of the design of ZIO and Cats Effect. They were designed at the beginning to be modular, so you can just uh interop with them, and it's part of the design of uh both ZIO, Cats Effect, and as well as as as well Kio at the end. Those library were having run time you can change. So, it it makes it easy to to interop.

[00:18:03]In the case of Stream, um what what's happening in Kio is from a algebraic effect perspective, a stream is just an emit.

[00:18:13]So, it's just a new effect. So, you don't have a full library for FS2, you just have um a new effect and combinators on top of it, and that's enough to have FS2 capabilities in um in Kio. So, there is a talk about that from Adam on um verifying stream composition.

[00:18:34]That that works except the resources. We need an update in the kernel to manage the resources as good as what FS2 is doing.

[00:18:46]And then for Cats Effect, and that concerns me a lot at work cuz it's what I use currently. Like, I have libraries in Cats Effect and a new code base in Kio, um we have Tagless Final in Kio.

[00:19:01]>> [snorts] >> And the Tagless Final in Kio is uh actually some something that that is more uh human-friendly, and that would fit the criteria criteria of uh people that have been critical about Tagless Final in the past.

[00:19:18]And that just work. Like there is an article about that.

[00:19:22]You You can enter up the existing Tagless Final.

[00:19:25]Use Use it as an effect.

[00:19:27]And And resolve it.

[00:19:29]And the type inference work.

[00:19:34]That mean that this part like string and And this part is is You could remove that. The type inference would would give you the type.

[00:19:45]Which makes Tagless Final a lot more easier to to work with.

[00:19:50]>> [snorts] >> It's just an effect called Tagless or use.

[00:19:55]And um And that's it.

[00:19:58]So you don't have to to change anything you've been doing in Cats Effect.

[00:20:03]You just use Q and use this kind of effect to use the code and and combine the effect.

[00:20:13]So, let's go to the last part.

[00:20:16]And um I know a lot of you have have raised the hand about monads.

[00:20:20]But that's not the current subject.

[00:20:23]In the Scala community for the the past 2 years we talked a lot about direct styling and capture checking.

[00:20:31]And we we compare both of them for good reasons. They They push Scala 3 ergonomics to the max.

[00:20:38]Uh direct style is using context function.

[00:20:41]Uh Q is using a pending set. And if you take a look at at both definition from a bit from afar like they It's not like they look the same. It's just the difference is Q is lazy by default. And direct style is eager by default.

[00:20:58]And but you we still use Scala and we try to have the best uh ergonomics on top of Scala 3.

[00:21:06]>> [snorts] >> However, comparing the two or often uh could lead to shortcuts.

[00:21:14]And what happened in the past few years is we tried to convince ourselves we could do uh functional programming in the context of direct style. And if I give you an example, I'm I'm not even sure that most of you would know uh what is the error currently uh on the slide.

[00:21:32]Like which side is the correct side and which uh side could lead to unsafe behaviors in your program.

[00:21:39]Which is which won't be a problem at all once capture checking is activated.

[00:21:45]And um so what happened in the conversation we have when we compare the two is we have a lot of of discussions that um doesn't have the uh principle and also the the safety that we require for uh pure functional programming.

[00:22:07]So in this case um the left side would compile in in direct style but would be completely unsafe.

[00:22:17]Unless you use capture checking. And if it compiles that means it's safe. Like there are cases where that would compile and it's safe. And the other other parts is self safe for most of the times it compiles.

[00:22:31]So my point here is I have to remind you like in Scala 3 we have capture checking activated. We cannot use this structure and structure like ZIO [snorts] with just direct style. We need to build something like ZIO and that would be redoing the work ZIO is doing in Scala 3.

[00:22:53]Because you need to to hide that in your opaque type and to make sure some of the constructions are not using the implicit resolution.

[00:23:04]So what we happen is once the capture checking is less experimental, well, I hope as soon as possible, cuz that's amazing, uh we could integrate the text extension in Kio.

[00:23:15]We could increase by a lot the safety and performance of Kio.

[00:23:19]Uh once you have capture checking, you can do more aggressive inlining in Kio.

[00:23:23]You can have stronger guarantees in the in the kernel as well.

[00:23:26]So, that would be a very interesting.

[00:23:30]And we could maybe open the direct style in Kio.

[00:23:35]So, it started a bit as a joke uh between contributors, uh but a lot of the building blocks in Kio are written in direct style for performance reason.

[00:23:45]And they are not open to the users because I would expose to unsafe constructs, but once there is a uh capture checking activated, we could definitely open that path.

[00:24:00]Okay.

[00:24:02]So, could capture checking replace Kio?

[00:24:05]That would be great.

[00:24:07]And that would mean we would stop doing uh open source contributions and uh and and pulling our hair in in the compiler error and so on.

[00:24:18]But it would take a couple of talks, like maybe a full afternoon, to present all the effects from Kio.

[00:24:26]Like we we cannot really let's scratch the surface. We have to talk about the um yeah, isolate boundaries, what happen when you use a var in the context of async computation, uh what are the effect composition, what you can build on top of Kio, like for example, tagless is one of the example I I talked earlier. It's only like four to five lines of code to to build a tool for tagless final, but understanding what's going on would take more time, and would need like a lot more effort to to explain and and to do this advertise for it.

[00:25:00]So, that are part of the effect that are already available in in Q.

[00:25:05]In blue, you have what you would got from classical effect system. And in in red, that usually stuff you you will mostly find on in Q for now.

[00:25:16]We can maybe like uh for example, they are re-rewrite for streaming engines. So, for example, emit a is would be maybe more popular soon, but so far like having a streaming engine as emit is only in Q.

[00:25:32]So, you you can build on top of those effects and decompose.

[00:25:39]And that mean that for example, we have a parcel in Q that is very nice and can do a lot of stateful parsing and backtracking.

[00:25:47]Uh we have batching. Um so, if you have an API that you could group the queries together, you can have automatic batching of that API and so on and so on.

[00:25:59]So, the conclusion.

[00:26:03]If you are interested and you have a little bit of bandwidth, I currently with the emergence of AI, we don't have bandwidth anymore. Like uh there is so much stuff to read.

[00:26:13]Um Q it could could be worth exploring.

[00:26:16]Um if you want like advanced composition and you want to to check on the performance.

[00:26:22]And if you are already invested in in Zio and Cats Effect, um it's not a start over. There is by the by the internal interrupt, you could even define stuff in uh in Q and use them in in Zio.

[00:26:37]Um it lets you capitalize on all your code base. Everything you've written so far can be used and should not be changed. They they should be used as if.

[00:26:47]And uh don't hesitate to ask like if you have any questions. Like we are there for that.

[00:26:52]And wanted it to to provide inputs like if we have thought of of anything of this kind of use case.

[00:27:01]Thank you.

[00:27:03]>> [applause]