The "++" and "--" operators have been deprecated Xcode 7.3

A full explanation here from Chris Lattner, Swift's creator. I'll summarize the points:

1. It's another function you have to learn while learning Swift
2. Not much shorter than x += 1
3. Swift is not C. Shouldn't carry them over just to please C programmers
4. Its main use is in C-style for loop: for i = 0; i < n; i++ { ... }, which Swift has better alternatives, like for i in 0..<n { ... } (C-style for loop is going out as well)
5. Can be tricky to read and maintain, for eg, what's the value of x - ++x or foo(++x, x++)?
6. Chris Lattner doesn't like it.

For those interested (and to avoid link rot), Lattner's reasons in his own words are:

1. These operators increase the burden to learn Swift as a first programming language - or any other case where you don't already know these operators from a different language.

2. Their expressive advantage is minimal - x++ is not much shorter than x += 1.

3. Swift already deviates from C in that the =, += and other assignment-like operations returns Void (for a number of reasons). These operators are inconsistent with that model.

4. Swift has powerful features that eliminate many of the common reasons you'd use ++i in a C-style for loop in other languages, so these are relatively infrequently used in well-written Swift code. These features include the for-in loop, ranges, enumerate, map, etc.

5. Code that actually uses the result value of these operators is often confusing and subtle to a reader/maintainer of code. They encourage "overly tricky" code which may be cute, but difficult to understand.

6. While Swift has well defined order of evaluation, any code that depended on it (like foo(++a, a++)) would be undesirable even if it was well-defined.

7. These operators are applicable to relatively few types: integer and floating point scalars, and iterator-like concepts. They do not apply to complex numbers, matrices, etc.

Finally, these fail the metric of "if we didn't already have these, would we add them to Swift 3?"

I realize that this comment doesn't answer the question nevertheless there may be people looking for a solution how to keep these operators working and such a solution can be found in the bottom. 😇

I personally prefer ++ and -- operators. I can't agree with the opinion that they are tricky or hard to manage. Once the developer understand what these operators do (and we are talking about pretty simple stuff) the code should be very clear.

In the explanation why the operators were deprecated is mentioned that their main use was in C-style for loops. I don't know about others but I personally don't use C-style loops at all and there are still many other places or situations when ++ or -- operator is useful.

I would like to also mention that varName++ returns a value so it can be used in the return whereas varName += 1 can not.

For any of you who would like to keep these operators working here is the solution:

prefix operator ++ {}postfix operator ++ {}prefix operator -- {}postfix operator -- {}// Incrementprefix func ++(inout x: Int) -> Int {    x += 1    return x}postfix func ++(inout x: Int) -> Int {    x += 1    return (x - 1)}prefix func ++(inout x: UInt) -> UInt {    x += 1    return x}postfix func ++(inout x: UInt) -> UInt {    x += 1    return (x - 1)}prefix func ++(inout x: Int8) -> Int8 {    x += 1    return x}postfix func ++(inout x: Int8) -> Int8 {    x += 1    return (x - 1)}prefix func ++(inout x: UInt8) -> UInt8 {    x += 1    return x}postfix func ++(inout x: UInt8) -> UInt8 {    x += 1    return (x - 1)}prefix func ++(inout x: Int16) -> Int16 {    x += 1    return x}postfix func ++(inout x: Int16) -> Int16 {    x += 1    return (x - 1)}prefix func ++(inout x: UInt16) -> UInt16 {    x += 1    return x}postfix func ++(inout x: UInt16) -> UInt16 {    x += 1    return (x - 1)}prefix func ++(inout x: Int32) -> Int32 {    x += 1    return x}postfix func ++(inout x: Int32) -> Int32 {    x += 1    return (x - 1)}prefix func ++(inout x: UInt32) -> UInt32 {    x += 1    return x}postfix func ++(inout x: UInt32) -> UInt32 {    x += 1    return (x - 1)}prefix func ++(inout x: Int64) -> Int64 {    x += 1    return x}postfix func ++(inout x: Int64) -> Int64 {    x += 1    return (x - 1)}prefix func ++(inout x: UInt64) -> UInt64 {    x += 1    return x}postfix func ++(inout x: UInt64) -> UInt64 {    x += 1    return (x - 1)}prefix func ++(inout x: Double) -> Double {    x += 1    return x}postfix func ++(inout x: Double) -> Double {    x += 1    return (x - 1)}prefix func ++(inout x: Float) -> Float {    x += 1    return x}postfix func ++(inout x: Float) -> Float {    x += 1    return (x - 1)}prefix func ++(inout x: Float80) -> Float80 {    x += 1    return x}postfix func ++(inout x: Float80) -> Float80 {    x += 1    return (x - 1)}prefix func ++<T : _Incrementable>(inout i: T) -> T {    i = i.successor()    return i}postfix func ++<T : _Incrementable>(inout i: T) -> T {    let y = i    i = i.successor()    return y}// Decrementprefix func --(inout x: Int) -> Int {    x -= 1    return x}postfix func --(inout x: Int) -> Int {    x -= 1    return (x + 1)}prefix func --(inout x: UInt) -> UInt {    x -= 1    return x}postfix func --(inout x: UInt) -> UInt {    x -= 1    return (x + 1)}prefix func --(inout x: Int8) -> Int8 {    x -= 1    return x}postfix func --(inout x: Int8) -> Int8 {    x -= 1    return (x + 1)}prefix func --(inout x: UInt8) -> UInt8 {    x -= 1    return x}postfix func --(inout x: UInt8) -> UInt8 {    x -= 1    return (x + 1)}prefix func --(inout x: Int16) -> Int16 {    x -= 1    return x}postfix func --(inout x: Int16) -> Int16 {    x -= 1    return (x + 1)}prefix func --(inout x: UInt16) -> UInt16 {    x -= 1    return x}postfix func --(inout x: UInt16) -> UInt16 {    x -= 1    return (x + 1)}prefix func --(inout x: Int32) -> Int32 {    x -= 1    return x}postfix func --(inout x: Int32) -> Int32 {    x -= 1    return (x + 1)}prefix func --(inout x: UInt32) -> UInt32 {    x -= 1    return x}postfix func --(inout x: UInt32) -> UInt32 {    x -= 1    return (x + 1)}prefix func --(inout x: Int64) -> Int64 {    x -= 1    return x}postfix func --(inout x: Int64) -> Int64 {    x -= 1    return (x + 1)}prefix func --(inout x: UInt64) -> UInt64 {    x -= 1    return x}postfix func --(inout x: UInt64) -> UInt64 {    x -= 1    return (x + 1)}prefix func --(inout x: Double) -> Double {    x -= 1    return x}postfix func --(inout x: Double) -> Double {    x -= 1    return (x + 1)}prefix func --(inout x: Float) -> Float {    x -= 1    return x}postfix func --(inout x: Float) -> Float {    x -= 1    return (x + 1)}prefix func --(inout x: Float80) -> Float80 {    x -= 1    return x}postfix func --(inout x: Float80) -> Float80 {    x -= 1    return (x + 1)}prefix func --<T : BidirectionalIndexType>(inout i: T) -> T {    i = i.predecessor()    return i}postfix func --<T : BidirectionalIndexType>(inout i: T) -> T {    let y = i    i = i.predecessor()    return y}

Apple has removed the ++ and made it much simpler with the another old traditional way.

Instead of ++, you need to write +=.

Example:

var x = 1//Incrementx += 1 //Means x = x + 1 

Similarly for decrement operator --, you need to write -=

Example:

var x = 1//Decrementx -= 1 //Means x = x - 1

For for loops:

Increment Example:

Instead of

for var index = 0; index < 3; index ++ {    print("index is \(index)")}

You can write:

//Example 1for index in 0..<3 {    print("index is \(index)")}//Example 2for index in 0..<someArray.count {    print("index is \(index)")}//Example 3for index in 0...(someArray.count - 1) {    print("index is \(index)")}

Decrement Example:

for var index = 3; index >= 0; --index {   print(index)}

You can write:

for index in 3.stride(to: 1, by: -1) {   print(index)}//prints 3, 2for index in 3.stride(through: 1, by: -1) {   print(index)}//prints 3, 2, 1for index in (0 ..< 3).reverse() {   print(index)}for index in (0 ... 3).reverse() {   print(index)}

Hope this helps!