Try Expression

The try expression in Swift is an evaluation operator applied to functions, methods, initializers, properties, or subscripts that are marked with the throws keyword. It explicitly acknowledges that the subsequent code may propagate an error, halting the current execution path and transferring control flow to an enclosing catch block or propagating the error up the call stack.

Swift provides three distinct variations of the try expression, each dictating a specific error-handling behavior and return type modification.

Standard try

The standard try expression preserves the original return type of the throwing operation. It strictly requires an enclosing error-handling context. This context must be one of the following:

• A do-catch statement.
• A surrounding function signature that includes the throws or rethrows modifier.
• The top-level code of a script, a playground, or a main.swift file.

try expression

If the expression evaluates successfully, execution continues to the next statement. If an error is thrown, execution of the current scope terminates immediately, and the error is propagated to the nearest handling context.

Optional try?

The try? expression alters the return type of the throwing operation by wrapping it in an Optional. It suppresses error propagation, meaning it does not require a do-catch block or a throws/rethrows context.

let result = try? expression

• On Success: The expression evaluates to an Optional containing the return value. If the operation already returns an Optional, try? does not add an additional layer of optionality (no Optional<Optional<T>>).
• On Failure: The thrown error is completely discarded, and the expression evaluates to nil.

Forced try!

The try! expression disables error propagation by asserting that the throwing operation will never fail at runtime. Like try?, it does not require an error-handling context. The ! in try! signifies a runtime assertion that an error will not be thrown, not an unwrap operation on an optional type.

let result = try! expression

• On Success: The expression evaluates to the exact return type of the throwing operation. If the operation’s return type is already an optional, try! preserves that optionality; it does not force-unwrap the return value.
• On Failure: If an error is thrown, the application triggers a fatal runtime error and crashes immediately.

Syntactic Rules and Precedence

Placement in Chained Expressions When dealing with chained method calls or property accesses where multiple components might throw, the try keyword only needs to be declared once for the entire statement. It is typically placed at the beginning of the expression.

// Valid syntax for a chain where multiple elements may throw
let result = try object.throwingMethod().anotherThrowingMethod()

Precedence The try operator has low precedence. It applies to the entire expression to its right. If you need to scope the try to a specific sub-expression, you must use parentheses.

// 'try' applies to the result of (expression1 + expression2)
let result = try expression1 + expression2 

// 'try' applies only to expression1
let result = (try expression1) + expression2 

Concurrency Integration When evaluating an asynchronous throwing expression, try is combined with the await keyword. Syntactically, try (or its variants) must always precede await.

let result = try await asynchronousThrowingExpression

Master Swift with Deep Grasping Methodology!

Learn More