In Kotlin, a side effect is a change in the state of a program that occurs outside of the current function. A side effect can be caused by modifying a variable outside of a local scope(don’t worry we will look in detail), modifying the state of a database, making a network request, or updating a file. Side effects are considered impure because they introduce external dependencies and can cause unpredictable behavior.

Kotlin is a multi-paradigm programming language, which means that it supports both functional and imperative programming styles. In functional programming, a pure function is a function that has no side effects and produces the same output given the same input. Pure functions are predictable and easy to reason about, which makes them ideal for functional programming. In Kotlin, side effects are often managed using techniques such as monads or pure functional state.

A monad is a design pattern that is commonly used in functional programming to manage side effects. A monad is a data type that wraps a value and provides a way to chain together operations that can have side effects, while still maintaining referential transparency.

In other words, a monad is a way to encapsulate side effects and provide a functional interface for working with them. The key idea behind monads is that they provide a way to abstract away the complexity of side effects and provide a simple, composable interface for working with them.

What does mean by outside of local scope?

In programming, a function’s local scope refers to the area of the code where the function is defined. This includes any variables or parameters that are passed into the function as arguments. Any changes made to these variables or parameters within the function are considered to be within the function’s local scope.

For example, consider the following Kotlin function:

fun addTwoNumbers(a: Int, b: Int): Int {
    val sum = a + b
    return sum
}

In this function, the local scope includes the parameters a and b, as well as the variable sum. Any changes made to these variables or parameters within the function are considered to be within the local scope.

However, a function can also interact with variables or resources outside of its local scope. For example:

val x = 0

fun incrementX() {
    x++
}

In this case, the incrementX function modifies the value of the variable x, which is defined outside of the function’s local scope. Any changes made to x within the function are considered to be outside of its local scope, and are therefore side effects.

Similarly, a function that reads from or writes to a file, sends a network request, or interacts with a database is considered to have side effects, because it is changing the state of an external resource outside of its local scope.

Managing Side Effects in Kotlin

Managing side effects in Kotlin requires careful attention to how external dependencies are accessed and modified. One approach is to use functional programming techniques such as pure functions or monads to isolate side effects from the rest of the code. Another approach is to use the suspend keyword to manage asynchronous side effects in a coroutine scope.

Pure Functions in Kotlin

Pure functions in Kotlin are functions that have no side effects and always return the same output given the same input. Pure functions are easy to reason about and test, since they only depend on their input parameters and do not modify any external state.

Here’s an example of a pure function in Kotlin:

fun add(a: Int, b: Int): Int {
    return a + b
}

In this example, the add function takes two integers as input and returns their sum. The function has no side effects and always returns the same output given the same input. This makes the function pure and predictable.

In simple terms, if a function satisfies the below conditions, we can say it’s a pure function.

1. The function must always return a value.
2. It must not throw any exceptions or errors.
3. It must not mutate or change anything outside the scope of the function, and any changes within the function must also not be visible outside its scope.
4. It should not modify or change its argument.
5. For a given set of arguments, it should always return the same value.

A function that does not satisfy the above conditions is called an impure function (We will look at its definition and examples later here in this article)

Based on these conditions, let’s analyze and classify the functions as pure and impure:

1. Pure function without conditions:

fun multiply(a: Int, b: Int): Int {
    return a * b
}

• Returns value: ✅ (The function returns the product of a and b, an integer.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ✅ (For a given set of a and b, the function will always return the same result.)

2. Pure function with conditions:

fun getPositiveNumber(number: Int): Int {
    return if (number >= 0) number else 0
}

• Returns value: ✅ (The function returns an integer, either number or 0 based on the condition.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ✅ (For a given value of number, the function will always return the same result.)

3. Pure function with immutable data structures:

fun appendElementToList(list: List<Int>, element: Int): List<Int> {
    return list + element
}

• Returns value: ✅ (The function returns a new list by appending element to the original list.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ✅ (For the same list and element, the function will always return the same resulting list.)

4. Pure function using Kotlin Standard Library functions:

fun calculateAverage(numbers: List<Double>): Double {
    return numbers.average()
}

• Returns value: ✅ (The function returns the average of the numbers list.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ✅ (For the same numbers list, the function will always return the same average.)

5. Impure function with side effects:

fun updateGlobalCounter(value: Int) {
    globalCounter += value
}

• Returns value: ❌ (The function doesn’t have a return type, and it doesn’t return any value.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ❌ (The function modifies the external variable globalCounter, causing a side effect.)
• Always returns the same value for the same input: N/A (The function doesn’t return any value, so this condition is not applicable.)

6. Impure function with changing results:

fun getRandomNumber(): Int {
    return (1..100).random()
}

• Returns value: ✅ (The function returns an integer, a random number between 1 and 100.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ❌ (The function returns different random values on each call, making it impure.)

7. Impure function with exception:

fun divide(a: Int, b: Int): Int {
    if (b == 0) throw IllegalArgumentException("Cannot divide by zero.")
    return a / b
}

• Returns value: ✅ (The function returns the result of the division a / b if b is not zero.)
• No exceptions or errors: ❌ (The function throws an exception when b is zero, making it impure.)
• No mutation of argument or external dependencies: ✅ (The function doesn’t modify any arguments or external variables.)
• Always returns the same value for the same input: ✅ (For the same a and b (excluding the case where b is zero), the function will always return the same result.)

8. Impure function with external dependency:

fun fetchUserData(userId: String): User {
    // Code to fetch user data from an external service/database
    // and return the user object.
}

• Returns value: ✅ (The function is expected to return a User object fetched from an external service/database.)
• No exceptions or errors: ❌ (The function may throw exceptions if the external service is down or there’s a data retrieval issue.)
• No mutation of argument or external dependencies: ❌ (The function interacts with an external service/database, making it impure.)
• Always returns the same value for the same input: N/A (The function’s behavior depends on the external service/database, so this condition is not applicable.)

9. Impure function modifying mutable data:

fun incrementListItems(list: MutableList<Int>) {
    for (i in 0 until list.size) {
        list[i]++
    }
}

• Returns value: ❌ (The function doesn’t have a return type, and it doesn’t return any value.)
• No exceptions or errors: ✅ (There are no exceptions or errors in the function.)
• No mutation of argument or external dependencies: ❌ (The function modifies the list by incrementing its elements, causing a side effect.)
• Always returns the same value for the same input: N/A (The function doesn’t return any value, so this condition is not applicable.)

Impure Functions in Kotlin

Impure functions in Kotlin are functions that have side effects and modify external state. Impure functions can be more difficult to reason about and test, since they can have unpredictable behavior depending on the current state of the program.

Here’s an example of an impure function in Kotlin:

var counter = 0
fun incrementCounter() {
    counter++
    println("Counter is now $counter")
}

In this example, the incrementCounter function modifies the value of the counter variable outside of the local scope of the function. This introduces a side effect, since the function modifies external state. The function also prints the current value of the counter variable, which is another side effect.

Let’s see a few more examples of side effects in Kotlin

1. Reading and Writing to a File

fun writeToFile(filename: String, content: String) {
    File(filename).writeText(content)
}

This function writes the input content to a file specified by filename. Writing to a file is an example of a side effect because it modifies the state of an external resource outside of its local scope.

2. Changing the Value of a Variable

var x = 0
fun increment() {
    x++
}

This function increments the value of a global variable x by 1. Modifying the value of a variable outside of the local scope of a function is an example of a side effect.

3. Sending an HTTP Request

fun fetchJson(url: String): String {
    val json = URL(url).readText()
    return json
}

This function sends an HTTP request to retrieve JSON data from a specified url. Sending an HTTP request is an example of a side effect because it interacts with an external resource outside of its local scope.

Kotlin Coroutines

Kotlin coroutines provide a way to manage asynchronous side effects in Kotlin. Coroutines are lightweight threads that allow you to write asynchronous code in a synchronous style. Coroutines allow you to suspend the execution of a function until a result is available, without blocking the main thread.

Here’s an example of using coroutines to manage a network request in Kotlin:

import kotlinx.coroutines.*
import java.net.URL

suspend fun fetchUrl(url: String): String {
    return withContext(Dispatchers.IO) {
        URL(url).readText()
    }
}

In this example, we’re using the withContext function to execute a network request in a coroutine scope. The withContext function takes a coroutine context and a suspendable block of code, and suspends the coroutine until the block completes.

Dispatchers.IO is a coroutine dispatcher that is optimized for I/O operations such as network requests. By using withContext, we’re able to manage the side effect of a network request without blocking the main thread.

Here’s an example of using a monad in Kotlin to manage a network request:

import arrow.core.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.net.URL

suspend fun fetchUrl(url: String): Either<Throwable, String> {
    return withContext(Dispatchers.IO) {
        Either.catch { URL(url).readText() }
    }
}

In this example, we’re using the Either monad from the Arrow library to manage a network request in a functional way. Either monad is used to represent a computation that can return either a value or an error. The catch function is used to catch any exceptions that may occur during the network request and return an error value.

By using a monad, we’re able to encapsulate the side effects of the network request and provide a functional interface for working with the result. This makes it easier to reason about and test the code and also makes it easier to compose multiple side-effecting computations together.

How to Avoid Side Effects?

Consider the following simple function that takes a list of integers, adds a new value to it, and returns the updated list:

fun addValue(list: MutableList<Int>, value: Int): MutableList<Int> {
    list.add(value)
    return list
}

This function modifies the state of the input list by adding a new element to it. This is an example of a side effect, as the function changes the state of an object outside of its local scope.

To avoid side effects, you could modify the function to create a new list instead of modifying the input list directly:

fun addValue(list: List<Int>, value: Int): List<Int> {
    return list + value
}

This function takes a read-only list as input and returns a new list that includes the input value. The input list is not modified, and there are no side effects. as we know side effects occur when a function modifies state outside of its local scope. By using functional programming techniques, you can reduce side effects and make your code more maintainable and predictable.

What about Jetpack Compose Side Effects?

The concept of side effects is present in both functional programming (Kotlin) and Jetpack Compose, but there are some differences in how they are handled.

In functional programming, a pure function is a function that has no side effects and produces the same output given the same input. Pure functions are predictable and easy to reason about, which makes them ideal for functional programming. Side effects in functional programming are usually avoided, but when necessary, they are managed using techniques such as monads or pure functional state.

In Jetpack Compose, on the other hand, side effects are a common occurrence due to the nature of UI programming, where interactions with external resources such as databases, network requests, or sensors are often necessary. Jetpack Compose provides a way to manage side effects using the LaunchedEffect and SideEffect APIs, which allow you to execute side effects in a controlled and predictable manner.

Here’s an example:

@Composable
fun MyComposable() {
    val context = LocalContext.current
    var myData by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {
        val result = fetchDataFromDatabase(context)
        myData = result
    }

    Text(text = myData)
}

suspend fun fetchDataFromDatabase(context: Context): String {
    // perform some asynchronous operation to fetch data from a database
    return "Hello, softAai!"
}

In this example, we’re using LaunchedEffect to fetch data from a database asynchronously and update the UI when the data is available. LaunchedEffect is a composable function that runs a side effect in a coroutine scope. In this case, we’re using a suspend function fetchDataFromDatabase to fetch data from a database and update the UI with the result.

The remember function is used to store the current state of myData, which is initially an empty string. Once the data is fetched from the database, we update the state of myData with the result.

By using LaunchedEffect, we’re able to manage the asynchronous nature of the side effect and update the UI when the data is available. This helps to keep our composable functions pure and predictable, while still allowing us to interact with external resources.

Another important distinction is that functional programming emphasizes the avoidance of side effects, while Jetpack Compose acknowledges that side effects are often necessary in UI programming and provides tools to manage them. However, both approaches share the goal of maintaining predictability and reducing complexity in software development.

Conclusion

Managing side effects in Kotlin requires careful attention to how external dependencies are accessed and modified. Using functional programming techniques such as pure functions and monads, or managing asynchronous side effects with coroutines, can help isolate side effects from the rest of the code and make it easier to reason about and test.

By understanding how side effects work in Kotlin, you can write more predictable and maintainable code that is less prone to bugs and errors. It’s important to use best practices for managing side effects and to understand how different approaches can affect the behavior of your program.