If Expression

An if expression in Swift is a control flow construct that evaluates a boolean condition and directly yields a value from the executed branch. Introduced in Swift 5.9, it allows if constructs to be parsed and evaluated as expressions rather than statements, enabling their direct use in variable assignments, return statements, and property initializers without mutating state or relying on the ternary operator (?:).

let variableName = if condition {
    expression1
} else if secondaryCondition {
    expression2
} else {
    expression3
}

Core Mechanics and Compiler Rules

To be evaluated as an expression rather than a statement, the if construct must adhere to strict compiler rules regarding exhaustiveness, branch composition, and type resolution.

1. Exhaustiveness Requirement Unlike an if statement, an if expression must guarantee that a value is produced regardless of the evaluation path. Syntactically, Swift strictly requires an else branch for an if expression. Without an else branch, the compiler parses the construct as a statement rather than an expression. This makes it invalid on the right side of an assignment or return, even if the expected return type of the expression is Void.

2. Single-Expression Branches Each branch within the if expression must contain exactly one expression. The compiler implicitly returns the result of this single expression. If a branch contains multiple statements (such as logging or intermediate variable declarations), the compiler cannot infer the yield value, and the construct reverts to being treated as a standard if statement.

// Valid: Single expression per branch
let result = if isValid {
    "Authorized"
} else {
    "Denied"
}

// Invalid: Multiple statements in a branch break the expression evaluation
let result = if isValid {
    print("Checking validity") 
    "Authorized" // Compiler Error
} else {
    "Denied"
}

3. Type Consistency and Inference The Swift compiler must be able to determine a single, unified return type for the entire if expression. By default, the single expression in every branch must evaluate to the exact same type.

// Valid: Both branches return 'Int'
let count = if hasItems { 10 } else { 0 }

// Invalid: Branches return 'Int' and 'String'
let value = if hasItems { 10 } else { "None" } // Compiler Error: Branches have mismatching types

4. Contextual Type Resolution If the branches return different types that share a common superclass or conform to a common protocol, the compiler will not automatically infer the common ancestor type. You must explicitly annotate the type of the receiving variable to provide the compiler with the necessary context for implicit conversion.

// Explicit existential type annotation 'any CustomStringConvertible' allows 
// branches to yield different underlying types (Int and String).
let message: any CustomStringConvertible = if isNumeric {
    404
} else {
    "Not Found"
}

5. Handling the Never Type If a branch evaluates to the Never type (for example, by calling fatalError() or throwing an error), the compiler successfully ignores that branch for type resolution. The expression’s unified type is inferred entirely from the remaining valid branches.

// Valid: The 'else' branch evaluates to 'Never', so the inferred type is 'Int'
let count = if hasItems {
    10
} else {
    fatalError("Invalid state")
}

Usage Contexts

The compiler recognizes an if expression in three specific syntactic positions:

• Assignment: On the right-hand side of a = operator (let or var declarations).
• Return: Directly following a return keyword in a function or closure.
• Implicit Return: As the sole expression in a single-expression function, closure, or computed property.

// Context: Implicit Return in a computed property
var statusIndicator: String {
    if isActive {
        "Online"
    } else {
        "Offline"
    }
}

Master Swift with Deep Grasping Methodology!

Learn More