How come I can create a variable with same name as a function parameter?

Question

In a function, if I'm being passed an int (which is immutable type, i.e let n), how come if I pass this into a function, I can create a var variable of this? Just wondering why swift works this way, and the reason for it .

func checkNum(_ n: Int) -> Bool {
    var n = n

}

In this, it let's me do this.

Answer 1

This is called "shadowing" and is allowed in a variety of places because it's convenient for the programmer because it avoids having two similarly named variables in scope. Without this feature, this code would be:

func checkNum(_ n: Int) -> Bool {
    var writableN = n
    ...
}

This raises the possibility of modifying writableN, and then using n again later in the function unintentionally. It also can make the function a bit harder to understand because of the extra variable. (Of course shadowing can also make code more difficult to understand as well, if it's used without care.)

This is very similar to the if let shadowing, such as:

var x: Int? = ...
if let x = x { ... }

This allows you to use x inside the if let as a non-Optional rather than having to come up with some other name for it.

This is a fairly general feature. Whenever there is a new scope, variables can shadow. For example, you can declare variables inside a function that have the same name as properties or globals. You can create scopes inside a function as well

func checkNum(_ n: Int) -> Bool {
    var n = n  // Shadows previous `let`

    do {
        let n = 4 // Shadows previous `var`
        print(n)
    }

    return true
}

Used with care, this is helpful. Used too often (as this last example definitely does), it can make the code very confusing.

Your specific case touches on another important aspect of Swift, which is that it tries to control shared mutable state. The n that the function receives is a copy of the integer that was passed. Modifying n would never directly modify the caller's variable. (There's inout to allow this, but it's subtle. It does't share state. It copies the value in, and on return, copies the value back out.)

Since n isn't shared with the caller, Swift makes this very explicit by making it immutable. If you want to modify it, you need to explicitly make another copy, and var n = n does that.