Kotlin Else Clause

​

Mechanics in if Constructs

• Statement Context: If the if construct is used as a statement (its return value is ignored), the else clause is optional.
• Expression Context: If the construct is used as an expression (assigned to a variable, passed as an argument, or returned), the else clause is mandatory. The compiler requires a guaranteed return value for all possible execution paths.

fun main() {
    val condition = false
    
    // Statement context: 'else' is optional but permitted
    if (condition) {
        println("Condition met")
    } else {
        println("Fallback executed") // Output: Fallback executed
    }

    // Expression context: 'else' is mandatory to satisfy the String return type
    val x = -5
    val result: String = if (x > 0) "Positive" else "Non-positive"
    
    println(result) // Output: Non-positive
}

​

Mechanics in when Constructs

fun main() {
    val subject = 3
    
    val outcome = when (subject) {
        1 -> "One"
        2 -> "Two"
        // Placing 'else ->' here would cause a compiler error
        else -> "Unknown" // Must be the final branch
    }
    
    println(outcome) // Output: Unknown
}

• Exhaustiveness Requirement: The else branch is mandatory whenever a when construct must be exhaustive, unless the compiler can statically verify that all possible cases are explicitly covered. Exhaustiveness is strictly required in the following scenarios:
  1. Expression Context: Whenever when is used as an expression, regardless of the subject type.
  2. Statement Context: Since Kotlin 1.7.0, non-exhaustive when statements for enum classes, sealed classes/interfaces, and Boolean subjects are enforced as a strict compiler error. If all possible values of these constrained types are not explicitly covered, the else branch is mandatory.

​

Block Evaluation and Return Types

• Implicit Unit: If the else branch does not explicitly evaluate to a value, its return type is implicitly Unit. If the corresponding if branch returns a specific type (e.g., Int), the common supertype resolves to Any.
• The Nothing Edge Case: If the else branch throws an exception or calls a function that returns Nothing (such as TODO()), the compiler resolves the overall expression type strictly to the type of the if branch. Because Nothing is a bottom type (a subtype of all types in Kotlin), it does not force the common supertype to Any.

fun main() {
    val flag = false
    
    // Block evaluation: the last expression (20) is the return value
    val value: Int = if (flag) {
        10
    } else {
        println("Executing side effect")
        20 
    }
    println(value) // Output: Executing side effect \n 20

    // Type resolution with Unit: Int and Unit resolve to Any
    val mixedType: Any = if (true) 42 else println("Returns Unit")
    println(mixedType) // Output: 42

    // Type resolution with Nothing: String and Nothing resolve to String
    val strictType: String = if (true) {
        "Valid String"
    } else {
        throw IllegalStateException("This branch returns Nothing")
    }
    println(strictType) // Output: Valid String
}