Swift Explicit vs. Inferred Typing : Performance

Question

I'm reading a tutorial about Swift (http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start) and it preconized to not set type explicitly because it's more readable this way.

I do not really agree about this point but that's not the question. My question is : Is it more efficient, in terms of performance (compiler...) to set type explicitly ?

For example, would this : var hello: Int = 56 be more efficient than this : var tutorialTeam = 56

Answer 1

There is no difference in performance between code that uses explicit types and code which uses type inference. The compiled output is identical in each case.

When you omit the type the compiler simply infers it.

The very small differences observed in the accepted answer are just your usual micro benchmarking artefacts, and cannot be trusted!

Whether or not you include the explicit type is a matter of taste. In some contexts it might make your code more readable.

The only time it makes a difference to your code is when you want to specify a different type to the one which the compiler would infer. As an example:

var num = 2

The above code infers that num is an Int, due to it being initialised with an integer literal. However you can 'force' it to be a Double as follows:

var num: Double = 2

Answer 2

Type inference will not affect performance in your given example. However, I did find that being specific about the Type in your Swift array does impact performance significantly.

For example, the method below shuffles an array of type Any.

class func shuffleAny(inout array: [Any]) {
    for (var i = 0; i < array.count; i++) {
        let currentObject: Any = array[i]
        let randomIndex = Int(arc4random()) % array.count
        let randomObject: Any = array[randomIndex]

        array[i] = randomObject;
        array[randomIndex] = currentObject
    }
}

The above function is actually much slower than if I were to make this function take an array of Int instead like this

class func shuffleIntObjects(inout array: [Int]) {
    for (var i = 0; i < array.count; i++) {
        let currentObject: Int = array[i]
        let randomIndex = Int(arc4random()) % array.count
        let randomObject: Int = array[randomIndex]

        array[i] = randomObject;
        array[randomIndex] = currentObject
    }
}

The function that uses [Any] clocked in at 0.537 seconds 3% STDEV for 1 million Int objects. And the function that uses [Int] clocked in at 0.181 seconds 2% STDEV for 1 million Int objects.

You can check out this repo (https://github.com/vsco/swift-benchmarks) which details a lot more interesting benchmarks in Swift. One of my favorite ones is that Swift generics perform very poorly with the test conditions mentioned above

Answer 3

From my experience, there's been a huge performance impact in terms of compilation speed when using explicit vs inferred types. A majority of my slow compiling code has been resolved by explicitly typing variables.

It seems like the Swift compiler still has room for improvement in this area. Try benchmarking some of your projects and you'll see a big difference.

Here's an article I wrote on how to speed up slow Swift compile times and how to find out what is causing it.