A Comprehensive Guide to Choosing Between Kotlin Scope Functions

Learn how Kotlin’s scope functions - let, run, with, apply, and also - provide a clean and concise way to execute code blocks within the context of an object
By İbrahim Korucuoğlu ( @siberoloji) |
Tags:
Categories:

  5 minute read  

A Comprehensive Guide to Choosing Between Kotlin Scope Functions

Kotlin’s scope functions - let, run, with, apply, and also - are powerful features that can make your code more concise and expressive. However, choosing the right scope function for a particular situation can be challenging. This guide will help you make informed decisions about which scope function to use in different scenarios.

Understanding the Key Differences

To choose the right scope function, we need to understand two key aspects:

  1. How the context object is referenced (this vs. it)
  2. What the function returns (context object vs. lambda result)

Quick Reference Table

Function | Object Reference | Return Value | Use Case
---------|-----------------|--------------|----------
let      | it             | Lambda       | Null checks, transformations
run      | this           | Lambda       | Object configuration + computing result
with     | this           | Lambda       | Grouping operations
apply    | this           | Context obj  | Object configuration
also     | it             | Context obj  | Side effects

Detailed Decision Guide

When to Use ’let'

Choose let when you:

  1. Need to perform null-safety checks
  2. Want to introduce a scoped variable
  3. Need to transform an object and use the result
// Null safety check
nullable?.let {
    // Code only executes if nullable is not null
    println(it)
}

// Scoped variable
val numbers = listOf(1, 2, 3)
numbers.firstOrNull()?.let { firstNumber ->
    println("First number is $firstNumber")
}

// Transformation
val length = str?.let {
    // Transform string to length
    it.length
}

When to Use ‘run’

Choose run when you:

  1. Need to execute multiple operations and compute a result
  2. Want to call object methods using ’this'
  3. Need to initialize an object and perform computations
// Computing a result
val result = bankAccount.run {
    if (balance < 0) throw IllegalStateException("Negative balance")
    balance * interestRate
}

// Multiple operations with result
val parsedText = input.run {
    trim()
    replace("old", "new")
    uppercase()
}

// Object initialization with computation
val config = Configuration().run {
    loadSettings()
    validate()
    computeHash()
}

When to Use ‘with’

Choose with when you:

  1. Want to group multiple operations on an object
  2. Don’t need null safety
  3. Are working with non-null objects frequently
// Grouping operations
with(person) {
    name = "John"
    age = 30
    address = "123 Main St"
    println("$name is $age years old")
}

// Working with builders
val result = with(StringBuilder()) {
    append("Start")
    append(calculateMiddle())
    append("End")
    toString()
}

// Multiple property access
with(settings) {
    enabled = true
    timeout = 1000
    protocol = "https"
}

When to Use ‘apply’

Choose apply when you:

  1. Need to configure an object
  2. Want to initialize object properties
  3. Need to chain configuration calls
// Object configuration
val textView = TextView(context).apply {
    text = "Hello"
    textSize = 16f
    textColor = Color.BLACK
}

// Builder-style initialization
val person = Person().apply {
    name = "Alice"
    age = 25
    email = "alice@example.com"
}

// Chained configuration
return NetworkConfig().apply {
    timeout = 5000
    retries = 3
}.apply {
    ssl = true
    proxy = Proxy.NO_PROXY
}

When to Use ‘also’

Choose also when you:

  1. Need to perform side effects
  2. Want to add logging or debugging
  3. Need to chain operations while keeping reference to the original object
// Logging
data.also {
    logger.debug("Processing data: $it")
}.process()

// Validation with side effects
user.also {
    validateUser(it)
    notifyUserCreated(it)
}

// Debugging in chains
numbers.map { it * 2 }
    .also { println("After mapping: $it") }
    .filter { it > 5 }
    .also { println("After filtering: $it") }

Common Patterns and Best Practices

Combining Scope Functions

Sometimes you might need to combine multiple scope functions for complex operations:

data class User(var name: String = "", var settings: Settings? = null)
data class Settings(var theme: String = "", var fontSize: Int = 0)

val user = User()
    .apply { name = "John" }
    .also { println("Created user: ${it.name}") }
    .apply {
        settings = Settings().apply {
            theme = "Dark"
            fontSize = 14
        }
    }

Avoiding Common Mistakes

  1. Don’t Overuse Scope Functions
// Bad
user.let {
    it.name = "John" // Unnecessary use of let
}

// Good
user.name = "John"
  1. Avoid Deep Nesting
// Bad
user.let {
    it.settings?.let {
        it.theme?.let {
            // Too deep!
        }
    }
}

// Good
when {
    user.settings?.theme != null -> {
        // Handle the case
    }
}
  1. Keep Lambda Bodies Concise
// Bad
object.apply {
    // 20+ lines of code
}

// Good
object.apply {
    initializeBasicProperties()
    configureSecurity()
    setupDefaults()
}

Decision Flowchart

When choosing a scope function, ask yourself these questions:

  1. Do you need null safety?

    • Yes → Consider let
    • No → Continue to 2

  2. Do you need to transform the object?

    • Yes → Use let or run
    • No → Continue to 3

  3. Are you configuring an object?

    • Yes → Use apply
    • No → Continue to 4

  4. Do you need to perform side effects?

    • Yes → Use also
    • No → Continue to 5

  5. Are you grouping operations?

    • Yes → Use with
    • No → Use regular functions

Conclusion

Choosing the right scope function is crucial for writing clean and maintainable Kotlin code. Remember these key points:

  • Use let for null safety and transformations
  • Use run for object operations with a result
  • Use with for grouping operations on non-null objects
  • Use apply for object configuration
  • Use also for side effects and logging

The best choice often depends on your specific needs regarding:

  • Null safety requirements
  • Whether you need to transform the object
  • Whether you need the context object or lambda result
  • Code readability and maintenance

Remember that while scope functions can make your code more concise, clarity should always be your primary goal. Don’t hesitate to use regular functions and properties when they make your code more readable and maintainable.


< apply and alsoInline Functions >
Last modified 20.02.2025: new kotlin and mint content (93a1000)