How to Use `when` Without an Argument in Kotlin

Kotlin, a statically typed programming language, offers features that make coding concise and straightforward. One of these features is the when expression, which allows developers to easily branch their code depending on the conditions. The when keyword can be used with or without an argument, and in this article, we'll delve into how to use when without an argument.

Understanding the when Expression

The when expression in Kotlin operates similarly to the switch-case structure found in other languages, but it's much more powerful. When used without an argument, it behaves like a series of if-else if-else statements.

Why Use when Without an Argument?

• Readability: Enhances the readability of conditional blocks.
• Versatility: It supports complex conditions, types, and combines multiple conditions in a clean syntax.
• Default Block: Like else in if conditions, it ensures there's a fall-back.

Basic Syntax

when {
    condition1 -> { /* code block for condition1 */ }
    condition2 -> { /* code block for condition2 */ }
    else -> { /* code block if no conditions match */ }
}

Here, each condition is checked sequentially. As soon as a true condition is found, its associated block is executed, and the rest are skipped.

Example: A Simple Weather Response System

Let's implement a simple weather response using the when expression without an argument.

fun respondToWeather(weather: String) {
    when {
        weather.contains("sunny", ignoreCase = true) -> println("It's a beautiful sunny day!")
        weather.contains("rainy", ignoreCase = true) -> println("Remember to take an umbrella.")
        weather.contains("cloudy", ignoreCase = true) -> println("It's a bit gloomy today.")
        else -> println("Weather is unpredictable today.")
    }
}

fun main() {
    respondToWeather("Sunny")  // Outputs: It's a beautiful sunny day!
    respondToWeather("rainy")  // Outputs: Remember to take an umbrella.
    respondToWeather("VERYCLOUDY")  // Outputs: It's a bit gloomy today.
    respondToWeather("unknown") // Outputs: Weather is unpredictable today.
}

In this example, the when expression checks the contents of the weather string to decide the response. The conditions use ignoreCase to handle variations in casing effectively.

Complex Conditions Inside when

You can leverage logical conditions to form more complex evaluations within the when statement.

val number = -10

when {
    number < 0 -> println("Negative number")
    number in 1..100 -> println("Positive number within range 1 to 100")
    number == 0 -> println("Zero")
    else -> println("Positive number greater than 100")
}

In this snippet, the when expression checks if the number is less than zero, within a specific range, equal to zero, or else comes to a logical conclusion.

Conclusion

Using when without an argument in Kotlin promotes clear and clean decision-making in code. It's a powerful part of the language that should certainly be part of every Kotlin developer's toolkit. Try out these examples, and you’ll soon appreciate the simplicity and readability when introduces to your code.