Golang := operator for multiple variables

Question

I'm starting using Golang as my main programming language to do exercises in LeetCode, and I get a strange result for Golang's := operator for multiple variables.

Let me say the question 104 to get the maxDepth of a binary tree.

My first solution is to use layer traversing, and below is my code.

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    var s []*TreeNode
    var cur *TreeNode
    depth := 0
    s = append(s, root)
    for len(s) != 0 {
        size := len(s)
        depth++
        for i := size; i > 0; i-- {
            s, cur = s[1:], s[0]
            if cur.Left != nil {
                s = append(s, cur.Left)
            }
            if cur.Right != nil {
                s = append(s, cur.Right)
            }
        }
    }
    return depth
}

The upper code snippet can pass the test. But the below code snippet can't, and I don't know why, I just can debug the for loop can't finish, and it becomes an infinite loop.

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    var s []*TreeNode
    depth := 0
    s = append(s, root)
    for len(s) != 0 {
        size := len(s)
        depth++
        for i := size; i > 0; i-- {
            s, cur := s[1:], s[0]
            if cur.Left != nil {
                s = append(s, cur.Left)
            }
            if cur.Right != nil {
                s = append(s, cur.Right)
            }
        }
    }
    return depth
}

I hope anyone can explain to me how Golang handles the := operators for multiple variables and at least one of which has already been declared in some other place. Also, you can put some official links which can prove your explanation.

Answer 1

If any new variable is on the left of := (which is required by the compiler) then all variables are redefined. This shadows previous variables in previous scopes.

In the second code sample, you create a new s and append to it, but the s defined before the for was not modified.

Answer 2

The assignment operator := isn't that big of a villain as you think it is. The actual culprit in you code is the scope of variable s.

In the first code snippet, the var s is defined outside the first (outer) for-loop. Inside inner for-loop it was only assigned.

var s []*TreeNode           // Definition
s, cur = s[1:], s[0]        // Assignment

Whereas in second code snippet, both statements are defining the same variable. In other words, the second assignment is creating a different var s whose scope is limited to second (inner) for-loop.

var s []*TreeNode           // Definition
s, cur = s[1:], s[0]        // Definition + Assignment

"So why does this cause a difference?", is the question. I've added example data and printing logic to your code snippets in Playground. Check by running them both.
1st Snippet
2nd Snippet

If you see outputs of both, the first logic (with only 1 definition) gives the expected output. But second logic (2 definitions) goes into an infinite loop. This is because the scope of the second s which got defined inside the for-loop starts after the second definition and ends with iteration of the same for-loop.

For understanding, let's call the s defined above for-loop as s_outer and the s defined inside for-loop as s_inner. Logically both should mean the same thing, but due to difference in scope, they act as follows:

for i := size; i > 0; i-- {
    s_inner, cur := s_outer[1:], s_outer[0]
    if cur.Left != nil {
        s_inner = append(s_inner, cur.Left)
    }
    if cur.Right != nil {
        s_inner = append(s_inner, cur.Right)
    }
}

Since assignment statement is executed right-to-left, first the compiler checks for s at s[1:], s[0]. Since s_inner is yet to be defined, it will consider s to be s_outer. When it assigns, i.e., control is now on the left side of = sign in s, cur := s[1:], s[0], since it is a new definition as per := usage in Go, it takes new variable s_inner. But the scope of s_inner ends after the current iteration. i.e., after if cur.Right != nil {...}. And so, from 2nd iteration, the s value is taken as s_outer again and assigned to s_inner. This gets repeated, and hence, infinite loop!!

---

Baseline: If a variable is defined with the same name as an existing variable but in an inner scope, it acts like a different variable altogether.

---

I doubt these concepts cannot be efficiently explained using description. Moreover, this is more of a use-case than property of the := operator. So, the godoc and other pages must've explained it as definition+assignment. You face an issue, you research and you learn. That's the only mantra for these concepts.