What’s New in Swift 2.2?

This time the decision was made to introduce amendments authored by 212 contributors unrelated to Apple. Swift 2.2 is to be a transitional stage before the release of version 3.0.

Selectors

So far, as we could pass as a selector a name of a method in the form of a string. In Swift 2.2 there is no such possibility. There was, however, introduced a new construction – #selector, which checks during compilation whether a particular method exists.

func noMoreStringSelector() {
	
}
 
func selectorTest() {
	let button = UIButton()
	// Swift 2.2
	button.addTarget(nil, action: #selector(noMoreStringSelector), forControlEvents: .AllEvents)
	
	// Before Swift 2.2
	button.addTarget(nil, action: "noMoreStringSelector", forControlEvents: .AllEvents)
}

Version verification

The creators decided also to introduce new, interesting construction which enables checking the version of Swift. This solution will certainly be appreciated by authors of libraries that must support several versions of the language.

#if swift(>=3.0)
	print("Swift 3.0 or later")
#else
	print("Swift 2.2 or earlier")
#endif

C style for loop is deprecated

Until now, we could use a standard C style construction for loop. However, with the new version of Swift, its creators decided to withdraw this option.

//Standard C-style for loop
for var i = 1; i <= 10; i+=1 {
    print(i)
}
//Modern Swift for loop, which may be used instead of
for i in 1...10 {
    print(i)
}

Operators ++ and — are deprecated

At first, this decision can slightly surprise us. The withdrawal of these operators is a consequence of the liquidation of the C style for loop, in which they were mainly used. Of course, if you still need incrementation, you can still use a substitute construction += 1.

var i = 0
i++ //Warning, XCode offers to use:
i += 1

The following code will stop working with version 3.0:

i++ 
i-- 
++i 
--i 
i = i++

Comparing tuples

Swift 2.2 allows us to compare tuples containing up to 6 elements. It is a simple but useful functionality.

let firstTuple = (1, 2, 3, "string")
let secondTuple = (1, 2, 3, "string")
if firstTuple == secondTuple {
    print("Tuples are equal")
}

More keywords that can be used as argument labels of functions

So far, we could use keywords as argument labels only if we saved them as such (the example uses repeat keyword):

func printName(name: String, `repeat` repeatCount: Int) {
    for _ in 0 ..< repeatCount {
        print(name)
    }
}

It is no longer necessary:

func printName(name: String, repeat repeatCount: Int) {
    for _ in 0 ..< repeatCount {
        print(name)
    }
}

printName("Holdapp", repeat: 5)

Adding removeFirst()

We might have had some problems with removing the first element of an array. In Swift 2.2, thanks to the removeFirst() method, we can now remove one or more first elements.

var elements = [1, 2, 3, 4, 5, 6]
elements.removeFirst()
print(elements) // [2, 3, 4, 5, 6]
elements.removeFirst(3)
print(elements) // [5, 6]

Most of the innovations introduced in Swift 2.2 will certainly be approved by its users. Of course, some changes seem controversial, but it has to be admitted that their implementation is fully justified.

Swift is growing very dynamically, so anyone who wants to keep up with this programming language should regularly follow Swift Evolution and the official changelog.