Expression Evaluation Orders

An Expression Is Evaluated After the Expressions It Depends on

• f() is evaluated later than its depended expressions, including f, x and y[n].
• the evaluation of the expression y[n] is later than the evaluations of n and y.

Initialization Order of Package-Level Variables

1. The first initialized variable is b, which is the first package-level variable without dependencies on other package-level variables.
2. The second initialized variable is a. After b is initialized, a is the first package-level variable without dependencies on uninitialized package-level variables.
3. The third and fourth initialized variables are _ and c. After a and b are initialized, _ and c both don't depend on uninitialized package-level variables.

package main

import "fmt"

var (
	_ = f()
	a = b / 2
	b = 6
	c = f()
)

func f() int {
	a++
	return a
}

func main() {
	fmt.Println(a, b, c) // 5 6 5
}

var m, n = expr1, expr2

var m = expr1
var n = expr2

• the variable a will be initialized after b for sure,
• but whether x is initialized before b, between b and a, or after a, is not specified.
• and the moment at which function sideEffect() is called (before or after x is initialized) is also not specified.

// x has a hidden dependency on a and b
var x = I(T{}).ab()
// Assume sideEffect is unrelated to x, a, and b.
var _ = sideEffect()
var a = b
var b = 42

type I interface    { ab() []int }
type T struct{}
func (T) ab() []int { return []int{a, b} }

• a bug in Go Toolchain 1.22.0 - 1.22.4.
• a bug in Go Toolchain versions prior to 1.23.

Operand Evaluation Orders in Logical Operations

The Usual Order

• the evaluation order of x (or y) and fa() (or fb()).
• the evaluation order of x, y, fa and fb.

y[z.f()], ok = g(h(a, b), i()+x[j()], <-c), k()

• c is a channel expression and will be evaluated to a channel value.
• g, h, i, j and k are function expressions.
• f is a method of expression z.

• The function calls, method calls and channel communication operations happen in the order z.f()→h()→i()→j()→<-c→g()→k().
• h() is evaluated after the evaluations of expressions h, a and b.
• y[] is evaluated after the evaluation of z.f().
• z.f() is evaluated after the evaluation of expression z.
• x[] is evaluated after the evaluation of j().

• The evaluation order of y, z, g, h, a, b, x, i, j, c and k.
• The evaluation order of y[], x[] and <-c.

	a := 1
	f := func() int { a++; return a }

	// x may be [1, 2] or [2, 2]: evaluation order
	// between a and f() is not specified.
	x := []int{a, f()}

	// m may be {2: 1} or {2: 2}: evaluation order
	// between the two map element assignments is
	// not specified.
	m := map[int]int{a: 1, a: 2}

	// n may be {2: 3} or {3: 3}: evaluation order
	// between the key and the value is unspecified.
	n := map[int]int{a: f()}

Evaluation and Assignment Orders in Assignment Statements

• If a destination expression is a blank identifier, then its elementary form is still a blank identifier.
• If a destination expression is a container (array, slice or map) index expression c[k], then its elementary form is (*cAddr)[k], where cAddr is a pointer pointing to c.
• For other cases, the destination expression must result an addressable value, then its elementary form is a dereference to the address of the destination expression evaluation result.

	a, b = b, a

// The evaluation phase:
P0 := &a; P1 := &b
R0 := b; R1 := a 

// The elementary form: *P0, *P1 = R0, R1

// The carry-out phase:
*P0 = R0
*P1 = R1

	x := []int{0, 0}
	i := 0
	i, x[i] = 1, 2
	fmt.Println(x) // [2 0]

// The evaluation phase:
P0 := &i; P1 := &x; T2 := i
R0 := 1; R1 := 2
// Now, T2 == 0

// The elementary form: *P0, (*P1)[T2] = R0, R1

// The carry-out phase:
*P0 = R0
(*P1)[T2] = R1

package main

import "fmt"

func main() {
	m := map[string]int{"Go": 0}
	s := []int{1, 1, 1}; olds := s
	n := 2
	p := &n
	s, m["Go"], *p, s[n] = []int{2, 2, 2}, s[1], m["Go"], 5
	fmt.Println(m, s, n) // map[Go:1] [2 2 2] 0
	fmt.Println(olds)    // [1 1 5]
}

// The evaluation phase:
P0 := &s; PM1 := &m; K1 := "Go"; P2 := p; PS3 := &s; T3 := 2
R0 := []int{2, 2, 2}; R1 := s[1]; R2 := m["Go"]; R3 := 5
// now, R1 == 1, R2 == 0

// The elementary form:
//     *P0, (*PM1)[K1], *P2, (*PS3)[T3] = R0, R1, R2, R3

// The carry-out phase:
*P0 = R0
(*PM1)[K1] = R1
*P2 = R2
(*PS3)[T3] = R3

	x := []int{2, 3, 5, 7, 11}
	t := x[0]
	var i int
	for i, x[i] = range x {}
	x[i] = t
	fmt.Println(x) // [3 5 7 11 2]

	x := []int{123}
	x, x[0] = nil, 456        // will not panic
	x, x[0] = []int{123}, 789 // will panic

package main

import "fmt"

func main() {
	f := func (p *int) int {
		*p = 99
		return *p
	}

	x := 0
	y, z := x+1, f(&x)
	fmt.Println(y, z)
}

package main

import "fmt"

func main() {
	x, y := 0, 7
	f := func() int {
		x++
		y++
		return x
	}
	fmt.Println(f(), y, f())
}

Expression Evaluation Orders in switch-case Code Blocks

package main

import "fmt"

func main() {
	f := func(n int) int {
		fmt.Printf("f(%v) is called.\n", n)
		return n
	}

	switch x := f(3); x + f(4) {
	default:
	case f(5):
	case f(6), f(7), f(8):
	case f(9), f(10):
	}
}

f(3) is called.
f(4) is called.
f(5) is called.
f(6) is called.
f(7) is called.

Expression Evaluation Orders in select-case Code Blocks

package main

import "fmt"

func main() {
	c := make(chan int, 1)
	c <- 0
	fchan := func(info string, c chan int) chan int {
		fmt.Println(info)
		return c
	}
	fptr := func(info string) *int {
		fmt.Println(info)
		return new(int)
	}

	select {
	case *fptr("aaa") = <-fchan("bbb", nil): // blocking
	case *fptr("ccc") = <-fchan("ddd", c):   // non-blocking
	case fchan("eee", nil) <- *fptr("fff"):  // blocking
	case fchan("ggg", nil) <- *fptr("hhh"):  // blocking
	}
}

bbb
ddd
eee
fff
ggg
hhh
ccc