Does "let _ = ..." (let underscore equal) have any use in Swift?

Question

Does using let _ = ... have any purpose at all?

I've seen question and answers for What's the _ underscore representative of in Swift References? and I know that the underscore can be used to represent a variable that isn't needed.

This would make sense if I only needed one value of a tuple as in the example from the above link:

let (result, _) = someFunctionThatReturnsATuple()

However, I recently came across this code:

do {
    let _ = try DB.run( table.create(ifNotExists: true) {t in
        t.column(teamId, primaryKey: true)
        t.column(city)
        t.column(nickName)
        t.column(abbreviation)
        })

} catch _ {
    // Error throw if table already exists
}

I don't get any compiler warnings or errors if I just remove the let _ =. It seems to me like this is simpler and more readable.

try DB.run( table.create(ifNotExists: true) {t in
    t.column(teamId, primaryKey: true)
    t.column(city)
    t.column(nickName)
    t.column(abbreviation)
    })

The author of the code has written a book and a blog about Swift. I know that authors aren't infallible, but it made me wonder if there is something I am missing.

Answer 1

You will get a compiler warning if the method has been marked with a warn_unused_result from the developer documentation:

Apply this attribute to a method or function declaration to have the compiler emit a warning when the method or function is called without using its result.

You can use this attribute to provide a warning message about incorrect usage of a nonmutating method that has a mutating counterpart.

Answer 2

Using let _ = ... specifically tells the compiler that you know that the expression on the right returns a value but that you don't care about it.

In instances where the method has been marked with warn_unused_result, if you don't use the underscore then the compiler will complain with a warning. (Because in some cases it could be an error to not use the return value.)

Answer 3

Sometimes it is simple and cleaner to use try? than do-catch, when you call something that throws, but decided not to handle any errors. If you leave call with try? as-is, compiler will warn you about unused result, which is not good. So you can discard results using _.

Example:

let _ = try? NSFileManager.defaultManager().moveItemAtURL(url1, toURL: url2)

Answer 4

Also, let _ = or _ = can be used when right side of expression is lazy variable and you want it calculated right now, but have no use for the value of this variable yet.

A lazy stored property is a property whose initial value is not calculated until the first time it is used. You indicate a lazy stored property by writing the lazy modifier before its declaration.

Lazy properties are useful when the initial value for a property is dependent on outside factors whose values are not known until after an instance’s initialization is complete. Lazy properties are also useful when the initial value for a property requires complex or computationally expensive setup that should not be performed unless or until it is needed.

---

Example:

final class Example {
    private func deepThink() -> Int {
        // 7.5 million years of thinking
        return 42
    }

    private(set) lazy var answerToTheUltimateQuestionOfLifeTheUniverseAndEverything: Int = deepThink()

    func prepareTheAnswer() {
        _ = answerToTheUltimateQuestionOfLifeTheUniverseAndEverything
    }

    func findTheQuestion() -> (() -> Int) {
        // 10 millions of thinking
        let theQuestion = {
            // something
            return self.answerToTheUltimateQuestionOfLifeTheUniverseAndEverything
        }

        return theQuestion
    }
}

let example = Example()
// And you *want* to get the answer calculated first, but have no use for it until you get the question
example.prepareTheAnswer()

let question = example.findTheQuestion()
question()

Answer 5

It's also useful to print() something in SwiftUI.

struct ContentView: View {
    var body: some View {
        let _ = print("View was refreshed")
        Text("Hi")
    }
}

View was refreshed

You can use it to see the current value of properties:

struct ContentView: View {
    @State var currentValue = 0

    var body: some View {
        let _ = print("View was refreshed, currentValue is \(currentValue)")
        Button(action: {
            currentValue += 1
        }) {
            Text("Increment value")
        }
    }
}

View was refreshed, currentValue is 0
View was refreshed, currentValue is 1
View was refreshed, currentValue is 2
View was refreshed, currentValue is 3
View was refreshed, currentValue is 4

If you just did _ = print(...), it won't work:

struct ContentView: View {
    var body: some View {
        _ = print("View was refreshed") /// error!
        Text("Hi")
    }
}

Type '()' cannot conform to 'View'; only struct/enum/class types can conform to protocols

Answer 6

You can user also @discardableResult in your own functions if sometimes you don't need the result.

@discardableResult    
func someFunction() -> String {

}

someFunction() // Xcode will not complain in this case

Answer 7

if let _ = something {
    ...
}

is equal to

if something != nil {
    ...
}

If you replaced the underscore with a property name, the fix that Xcode would suggest is the second option (it would not suggest the first). And that's because the second option makes more programming sense. However—and this is something Apple themselves stress to developers—write the code that is the most readable. And I suspect the underscore option exists because in some cases it may read better than the other.