In Swift, handling optionals is an essential part of ensuring your code’s safety and reliability. While the ! operator provides a quick way to force-unwrap optionals, it often leads to runtime crashes without much information on what went wrong. This lack of detail can be frustrating when debugging, especially if the crash occurs in a production environment. In this post, we’ll explore some custom operators to improve the clarity and safety of unwrapping optionals in Swift.

The Problem with Force Unwrapping

When you force-unwrap an optional using !, you’re essentially telling Swift, “I’m sure this value isn’t nil, and it’s safe to use.” However, if the value is nil, the program will crash, and you’ll only see a generic error message. This lack of context can make it challenging to understand what went wrong and why.

Introducing the !! Operator

To enhance error reporting, we can define a custom operator !!. This operator not only force-unwraps the optional but also allows us to provide a descriptive error message that gets logged if the unwrapping fails.

infix operator !!

func !! <T>(wrapped: T?, failureText: @autoclosure () -> String) -> T {
    if let x = wrapped { return x }
    fatalError(failureText())
}

Using !!, you can include a custom error message, providing valuable context when a crash occurs. For example:

let s = "foo"
let i = Int(s) !! "Expecting integer, got \"\(s)\""

In this case, if the conversion fails, the error message will indicate that the string "foo" could not be converted to an integer, making debugging easier.

Asserting in Debug Builds with the !? Operator

While crashing with detailed error messages is useful during development, it’s often too severe for production. In production builds, we might prefer to handle unexpected nil values gracefully. The !? operator allows us to assert during debugging and substitute a default value in production.

infix operator !?

func !?<T: ExpressibleByIntegerLiteral>(wrapped: T?, failureText: @autoclosure () -> String) -> T {
    assert(wrapped != nil, failureText())
    return wrapped ?? 0
}

func !?<T: ExpressibleByArrayLiteral>(wrapped: T?, failureText: @autoclosure () -> String) -> T {
    assert(wrapped != nil, failureText())
    return wrapped ?? []
}

func !?<T: ExpressibleByStringLiteral>(wrapped: T?, failureText: @autoclosure () -> String) -> T {
    assert(wrapped != nil, failureText())
    return wrapped ?? ""
}

With !?, you can provide default values for different types. For instance:

let s = "20"
let i = Int(s) !? "Expecting integer, got \"\(s)\""

In debug builds, this will assert if the conversion fails. In release builds, it will return 0 instead of crashing.

Custom Default Values

Sometimes, the default values provided by the type aren’t sufficient. In such cases, we can define a version of !? that accepts a pair: a default value and an error message.

func !?<T>(wrapped: T?, nilDefault: @autoclosure () -> (value: T, text: String)) -> T {
    assert(wrapped != nil, nilDefault().text)
    return wrapped ?? nilDefault().value
}

For example:

Int(s) !? (5, "Expected integer")

In debug builds, it asserts if s can’t be converted to an integer. In release, it defaults to 5.

Handling Void Optionals

The !? operator can also be adapted for optionally chained method calls, which return Void?:

func !?(wrapped: ()?, failureText: @autoclosure () -> String) {
    assert(wrapped != nil, failureText())
}

This is useful when you expect a method chain to execute and don’t want to silently fail if an optional chain breaks:

var output: String? = nil
output?.write("something") !? "Wasn't expecting chained nil here"

Conclusion

These custom operators provide more control over optional unwrapping in Swift. By using !! and !?, you can improve error handling during development and provide safer defaults in production. Remember, while these tools can be helpful, they should be used judiciously. Over-reliance on force-unwrapping, even with better error messages, can still lead to crashes. Always consider safer alternatives like optional binding (if let) and nil-coalescing (??).

Incorporate these operators into your codebase to make your Swift applications more robust and your debugging process more informative. Happy coding!