Is it safe to force unwrap an optional after checking it is not nil

Question

I have a network method that return me a completion closure with an Error as the parameter.

I usually avoid force unwrapping, but in that case, I use a guard statement to check if error is not nil:

guard error == nil else {
    print(error!)
    return
}

...

The method I'm calling is from an SDK so I don't really know what happens in there.

In general, is this force unwrapping thread safe or not?

Answer 1

The difference between if and guard is just simple, but in your case, you should use if, not guard. guard should be used when some values are expected to be present for the function to execute as intended. You don't want error to be present, but if it is not nil, you have to return. So you should use if let:

if let error = error {
    print(error)
    return
}

This way, you don't need to use force unwrapping and it improves how your code is represented.

Back to your question "In general, is this force unwrapping thread safe or not?", assuming that you are really talking about thread safety, it is certainly thread safe. Closure variables are immutable.

If you are talking about safety (ie will "fatal error: unexpectedly found nil while unwrapping an Optional value" occur), it is also certainly safe. error must not be nil before you can unwrap it (because of guard), so the force unwrapping is safe.

In conclusion, your current code is bulletproof, but using if let might be better.