> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift 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. ```swift theme={"dark"} 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. ```swift theme={"dark"} 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>`). * **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. ```swift theme={"dark"} 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. ```swift theme={"dark"} // 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. ```swift theme={"dark"} // '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`. ```swift theme={"dark"} let result = try await asynchronousThrowingExpression ```

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More