We could print some value, fun loggingAdd(x: Int, y: Int): Int Īt a conceptual level, you can think of Continuation as simply a function (A) -> Unit.

In Kotlin, we can easily sneak in other types of behaviors, which we often call side effects.

Here, the types are 'honest ' we always get back a number, and such a number depends only on the input arguments. By default, this is only the case for pure functions, which is a fancy way of saying 'functions that only do computation.' Take the following function: fun add(x: Int, y: Int): Int = x + y The idea is to be explicit about the visible behavior of a function in its signature since that allows for more powerful compiler checks and analyses. Effectsīefore diving into the technical portion, let’s discuss what we aim to achieve when talking about effects. There are still some rough edges when mixing them with suspend and inline, but the Kotlin team is clearly putting lots of effort toward making them stable. Warning: Context receivers are still experimental, per the 1.7.x series. Good resources to understand that style are Scala with Cats, Practical FP in Scala, or the Book of Monads. This post assumes the reader is familiar with the transformer-style of effects. This post aims to clarify how this style works in Kotlin, compare it to other sibling languages, and discuss the main limitations.

Functional programming patterns inspire many concepts, but the specific implementation differs from Haskell’s or Scala’s typical way of doing things (monads, IO, and transformers). The Arrow project, in particular starting with its 2.0 version, promotes a specific style of Kotlin to achieve composability of effects.

With context kotlin