Why is the implementation of the map function of Collection inconsistent with the actual

I recently read the Swift source code and saw that the map function of Collection is implemented as follows

   @inlinable
   public func map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
     // TODO: swift-3-indexing-model - review the following
     let n = self.count
     if n == 0 {
       return []
     }
     var result = ContiguousArray<T>()
     result. reserveCapacity(n)
     var i = self. startIndex
     for _ in 0..<n {
       result.append(try transform(self[i]))
       formIndex(after: &i)
     }
     _expectEnd(of: self, is: i)
     return Array(result)
   }

It seems that the map function will visit the i subscript elements in turn according to its own size, and call the transform closure parameter one by one.

I wrote the following code to verify, and found that it is different from the Collection source code implementation

var array = [0, 1, 2]
array.map { index -> Void in
     array[2] = -1
     print("\(index)")
}

According to the Collection source code, the print result of this code should be

0
1
-1

but actually it prints

0
1
2

I'm wondering why this code behaves inconsistently with the source code.

Update：

It looks like there is some misunderstanding in my example code. Actually I know the correct usage of map, I just want to verify my understanding of the source code.

So for the sake of accuracy, I decided to modify my example code a bit

var array = [0, 1, 2]
let newArray = array. map { element -> Int in
      array[element] = -1
      return element
}
print(array)
print(newArray)

Now this code uses map correctly, and I modify the content of array in map, and return element to form newArray, the printed result is as follows

[-1, -1, -1]
[0, 1, 2]

Let me rewrite this in a simpler way that I believe will be uncontroversial, and then hopefully it will be clear that your code is equivalent:

// A free function that accepts an array and a transform
func iterate(over: [Int], _ transform: (Int) -> Void) {
    let n = over.count
    var i = over.startIndex
    for _ in 0..<n {
        transform(over[i])
        over.formIndex(after: &i)
    }
}
var array = [0, 1, 2]
iterate(over: array) { value in
    array[2] = -1
    print(value)
}
print(array)

This will print the same as your example:

0
1
2
[0, 1, -1]

This is exactly as should be expected in Swift. over is a copy of array, so array[2] = -1 has nothing to do with over. Value-type parameters always are copies (even inout are copies; they just get copied back at the end). The behavior hopefully is clear from that.

The only difference between this and your example is that it is called as a function rather than a method, but that is no difference at all. over and self play precisely the same roles in this code and behave exactly the same way. self is a copy. To demonstrate, this is a mechanical conversion of the function taking Array to an extension on Array:

extension Array<Int> {
    func iterate(_ transform: (Int) -> Void) {
        let n = self.count
        var i = self.startIndex
        for _ in 0..<n {
            transform(self[i])
            self.formIndex(after: &i)
        }
    }
}
var array = [0, 1, 2]
array.iterate { value in
    array[2] = -1
    print(value)
}
print(array)

It behaves identically (as should be expected). Changing the parameter's name from over to self does not change the behavior. map is the same. It's equivalent to this (inlining the method):

var array = [0, 1, 2]
let `self` = array  // This makes a copy; `let` because it's non-mutating
let n = `self`.count
var i = `self`.startIndex
for _ in 0..<n {
    array[2] = -1
    print(`self`[i])
    `self`.formIndex(after: &i)
}
print(array)

For more on this, see Structures and Enumerations Are Value Types in The Swift Programming Language:

>In fact, all of the basic types in Swift — integers, floating-point numbers, Booleans, strings, arrays and dictionaries — are value types, and are implemented as structures behind the scenes.
>
>All structures and enumerations are value types in Swift. This means that any structure and enumeration instances you create — and any value types they have as properties — are always copied when they’re passed around in your code.

You are not actually using the map function correctly in your example, so it's unclear what you're trying to test. But if you append a further statement print(array) you will see that the original array was indeed changed.

    var array = [0, 1, 2]
    array.map { index -> Void in
        array[2] = -1
        print("\(index)")
    }
    print(array) // [0, 1, -1]

Your call to array[2] = -1 does not affect the array that we are looping over (and from which you are getting your poorly named index), because it is a copy of the original array.

You get an inconsistent result because actually you don't use the map functionality at all.

The signature of map

func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] 

means the following:

• It does not modify the array in place, it returns a new array with the transformed elements.
• In the closure (Element) throws -> T you get each element – which is an immutable copy of the element by the way – and you have to return the modified/transformed value.

index -> Void is pointless because you don't return anything in the closure, instead you modify the array in place, in practice you overwrite the 3rd element of the array with -1 three times. Further index is not the index, it's the element. If the array is [2, 4, 6] then index is 2, 4, 6 not 0, 1, 2.

If you want to set the element with value 2 to -1 using map you have to write

let result = array.map { element -> Int in
    if element == 2 {
        return -1
    } else {
        return element
    }
}

result will be [0, 1, -1], on the other hand array remains unchanged.

But the real purpose of map is a transformation like

let result = array.map { element -> String in
    return "\(element * 2) times"
}

Now result is ["0 times", "2 times", "4 times"]

The magic of generics is that you don't even need to specify the return type, this is sufficient

let result = array.map { "\($0 * 2) times" }