When we use the ! operator to force-unwrap an optional value in Swift Talk , we sometimes hear from viewers that it would be better not to use force-unwrapping. However, while we try to be very careful about force-unwrapping an optional value, it's mostly a very deliberate choice if we do force-unwrap. The key questions we ask ourselves in these cases is: does the nil value occur due to a programmer error?

Consider the example of creating an URL from a static string like this:

								let url: URL? = URL(string: "https://www.objc.io")

							

The URL initializer is failable, because not every string represents a valid URL:

								let url: URL? = URL(string: "🤔")
assert(url == nil)

							

However, if we create a URL from a static string, it's the programmer's responsibility to specify a valid URL. A string that results in a nil value is like a typo or a logic error in your code. Therefore we force-unwrap the result to crash immediately in case we've made a mistake:

								let url: URL = URL(string: "https://www.objc.io")!

							

If you use force-unwrapping like this carefully, you can read the ! character in your code as an assertion. It signifies a check for the correctness of your code.

We encountered a similar, though less obvious example when writing a concurrent map function in Swift Talk 90 :

								extension Array {
    func concurrentMap<B>(_ transform: @escaping (Element) -> B) -> [B] {
        var result = Array<B?>(repeating: nil, count: count)
        let q = DispatchQueue(label: "sync queue")
        DispatchQueue.concurrentPerform(iterations: count) { idx in
            let element = self[idx]
            let transformed = transform(element)
            q.sync {
                result[idx] = transformed
            }
        }
        return result.map { $0! }
    }
}

							

At the very end of the function, we map over the result array and force unwrap all the values. We could have avoided the force-unwrap by using flatMap instead of map , but this would only serve to mask potential programming errors. The result array must contain the same number of elements as the original array, i.e. there must not be a nil value in it. If there is, we have made a mistake and should crash immediately.

We talk much more about handling optionals in Swift Talk 93 : besides force-unwrapping, we look at API design with optionals, optional chaining, implicitly-unwrapped optionals and more.

Subscribe to access all our episodes.