快速关闭尾随问题？

Question

Hello i have a created a function which accepts last argument as closure.

func sum(from: Int, to: Int, f: (Int) -> (Int)) -> Int {
    var sum = 0
    for i in from...to {
        sum += f(i)
    }
    return sum
}

Now i when i call this function.One way to call this function is below like this .

sum(from: 1, to: 10) { (num) -> (Int) in
return 10
}

I have seen one of the concepts in swift as trailing closure.With trailing closure i can call the function like this .

sum(from: 1, to: 10) {
    $0
}

but i don't know why it is able to call without any return statement.please tell me how it is happening ?

Answer 1

There really is no answer here except "because the language allows it." If you have a single expression in a closure, you may omit the return .

The section covering this is "Implicit Returns from Single-Expression Closures" from The Swift Programming Language.

Single-expression closures can implicitly return the result of their single expression by omitting the return keyword from their declaration, as in this version of the previous example:

 reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } ) 

Here, the function type of the sorted(by:) method's argument makes it clear that a Bool value must be returned by the closure. Because the closure's body contains a single expression (s1 > s2) that returns a Bool value, there is no ambiguity, and the return keyword can be omitted.

This has nothing to do with trailing closure syntax, however. All closures have implicit returns if they are single-expression.

Answer 2

As @rob-napier states, you can do it just because the language allows it.

But, note your example is also doing two different things in that last part:

sum(from: 1, to: 10) {
    $0
}

Not only are you omitting the return statement, you're also omitting the named parameters, so the $0 is not dependant on the omitting the return feature.

This would be a more accurate example for just omitting return :

sum(from: 1, to: 10) { (num) -> (Int) in
    num
}

That said, I wouldn't recommend using either of these features . In most cases, it's better to make the code easier to read later. Your future self (and others who use the code after you) will thank you.