这种类型的封闭意味着什么，它如何工作？

Question

Got it from Here

The Ultimate Closure Finally, for the ultra parsimonious there is the following, without a byte wasted.

let testEquality9 : (Int, Int) -> Bool = (==)

Answer 1

This is not actually a closure, it's the equality operator that compares two integers stored into a variable.

Every operator is defined using a function and that function can be assigned to a variable. There is nothing else to it.

Answer 2

Functions decalred with the func keyword are just closures with names. == is an example of one such named function. It takes 2 Int arguements, and returns a Bool telling you if they're equal. Its type is (Int, Int) -> Bool

testEquality9 is a closure, with the type (Int, Int) -> Bool . To it, the closure of the == function is assigned.

It can be called like this:

testEquality9(1, 2) // false
testEquality9(1, 1) // true

The key thing to draw from this is that functions are really just closures, so they can be used everywhere closures can be used.

For example, if you wanted to sort an array of Ints, you could use:

let ints = [3, 1, 4, 2]
let sorted = ints.sort{$0 < $1}

The sort(_:) method takes a closure that's of type (Int, Int) -> Bool . Our closure {$0 < $1} takes 2 Int params, and returns a Bool . So it fits that signiture.

However, we can make this code shorter. Because the < operator's function already has type (Int, Int) -> Bool , we can write this:

let sorted = ints.sort(<)

This passes the function (named closure) < in directly, without explicitly making our own closure to wrap around it.

Answer 3

Operator Overloading:

func == (i : Int, j: Int) -> Bool {
     return i == j
}

Should be equivalent to that.

Answer 4

As the others said, it's the abbreviation form of:

let testEquality9: (Int, Int) -> Bool = { (a: Int, b: Int) -> Bool in return a == b }

Reading from right to left, it creates a function that compares two Ints and assigns it to the constant testEquality9.

You need to mentally separate the 3 pieces:

The constant name:

let testEquality9

The constant type (it's a function type):

(Int, Int) -> Bool

And the value assigned to the constant:

(==)

OR, the long version:

{ (a: Int, b: Int) -> Bool in return a == b }

Enjoy Swift :)