The main reason is the existence of better equivalents like for-in and stride(). for-loop is hard to understand on the fly and probably less-swifty. As it turns out, for-loop is not used much in existing Swift codebase.

The article describes typical for-loop usage scenarios. And explains how easily to migrate to for-in, stride() or simple while() {}.

1. How to migrate for-loop to for-in

The typical scenario of for-loop application is to iterate over an interval of numbers. These numbers can be indexes of an array, and so on.

It's visible that let index = 0; index < birds.count; index++ part of the loop is verbose. Many elements are redundant and the entire expression can be flatten.
Instead of manual incrementation, the whole operation can be automated with a more expressive syntax.

for-in loop is shorter and more expressive. Let's migrate the above code:

Much better now. index in 0..<birds.count is easier to read and understand.
The part 0..<birds.count defines an half-open interval of type Range. for-in loop iterates over 0, 1 and 2 range values (upper limit 3 is not included).

And that's not all! You can even skip the index and access directly the array elements:

stride(from: 0, to: colors.count, by: 2) returns numbers starting 0 until 5 (upper limit 5 not included), in a step by 2. This is a good alternative to for-loop.

If the upper limit must be included, there is a second form of the function: stride(from: value, through: value, by: value). The second parameter label is through, which indicates that the upper limit is included.

3. Other cases stick to while

C-style for-loop has a nice property that every component: the initialization, break verification and increment are fully configurable:

for <initialization>; <verification>; <increment> {
// loop body
}

Moreover you can omit any of these components, if you can break the loop in for-loop body block.

For example let's print the elements of an array of numbers and stop when 0 element is encountered. It possible to use the C-style for-loop:

5. Conclusion

Swift 3.0 has a nice list of changes. Many of them are breaking changes, so you have to put some efforts to migrate the Swift 2.3 or older code.

The Swift makers apply considerable efforts to make the language comfortable as much as possible.
Sometimes the process creates breaking changes. Fortunately it's a small price compared to increased code readability and consistency across the language syntax.

C-style elements like for-loop, unary increment and decrement operators are removed. For these constructs Swift offers better alternatives.
For instance C-style for-loop is easily replaced by for-in. You may apply stride() function for a more configurable iteration.