Control Flow

package main

import (
	"fmt"
	"strconv"
)

func parse(s string) (int, error) {
	// n and err are declared in the function scope, so they stay visible
	// after the if statement: no init statement here.
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("parse %q: %w", s, err)
	}
	return n * 2, nil
}

func main() {
	fmt.Println(parse("21"))
	fmt.Println(parse("x"))
}

42 <nil>
0 parse "x": strconv.Atoi: parsing "x": invalid syntax

package main

import "fmt"

func main() {
	n := 1
	if n {
		fmt.Println("truthy")
	}
	for n {
	}
	if n = 2; n > 1 {
		fmt.Println(m)
	}
	var s string
	if s != "" && n {
	}
	if !n {
	}
}

main.go:7:5: non-boolean condition in if statement
main.go:10:6: non-boolean condition in for statement
main.go:13:15: undefined: m
main.go:16:5: invalid operation: s != "" && n (mismatched types untyped bool and int)
main.go:18:6: invalid operation: operator ! not defined on n (variable of type int)

package main

import "fmt"

func main() {
	n := 1
	if n == 1 {
		fmt.Println("one")
	}
	else {
		fmt.Println("other")
	}
}

main.go:10:2: syntax error: unexpected keyword else, expected }

package main

import "fmt"

func main() {
	// Modifying the loop variable inside the body is still allowed and
	// still affects the loop: the value is copied into the next
	// iteration's fresh variable before the post statement runs.
	for i := 0; i < 10; i++ {
		if i%3 == 0 {
			i += 2 // skip ahead
		}
		fmt.Print(i, " ")
	}
	fmt.Println()

	// A range loop's variables are fresh each iteration, but assigning to
	// them never changes where the loop goes next.
	for i := range 5 {
		i += 10
		fmt.Print(i, " ")
	}
	fmt.Println()
}

2 5 8 11
10 11 12 13 14

package main

import "fmt"

func main() {
	var f float64
	for f = range 3 {
		fmt.Println(f)
	}
	for i, v := range 3 {
		fmt.Println(i, v)
	}
	ch := make(chan int)
	for i, v := range ch {
		fmt.Println(i, v)
	}
	for i := range 3.5 {
		fmt.Println(i)
	}
	var send chan<- int
	for v := range send {
		fmt.Println(v)
	}
}

main.go:7:6: cannot use iteration variable of type float64
main.go:10:9: range over 3 (untyped int constant) permits only one iteration variable
main.go:14:9: range over ch (variable of type chan int) permits only one iteration variable
main.go:17:17: cannot range over 3.5 (untyped float constant)
main.go:21:17: cannot range over send (variable of type chan<- int): receive from send-only channel chan<- int

package main

import "fmt"

func main() {
	for i := range 3 {
		fmt.Println(i)
	}
}

module example.com/old3

go 1.21

main.go:6:17: cannot range over 3 (untyped int constant): requires go1.22 or later (-lang was set to go1.21; check go.mod)

package main

import "fmt"

type Book struct {
	Title  string
	Copies int
}

func main() {
	books := []Book{{"Dune", 1}, {"Emma", 2}}

	// v is a copy of the element: changing it does not change the slice.
	for _, v := range books {
		v.Copies += 100
	}
	fmt.Println(books)

	// Use the index to modify in place...
	for i := range books {
		books[i].Copies += 100
	}
	fmt.Println(books)

	// ...or keep pointers in the slice.
	ptrs := []*Book{{"Dune", 1}, {"Emma", 2}}
	for _, p := range ptrs {
		p.Copies *= 10
	}
	fmt.Println(*ptrs[0], *ptrs[1])

	// Ranging over an array evaluates a copy of the whole array first when
	// the value variable is used; ranging over a slice shares its storage.
	arr := [3]int{1, 2, 3}
	for i, v := range arr {
		arr[2] = 99 // the loop still sees the copy
		if i == 2 {
			fmt.Println("array range sees", v)
		}
	}
	sl := []int{1, 2, 3}
	for i, v := range sl {
		sl[2] = 99 // the loop sees the update
		if i == 2 {
			fmt.Println("slice range sees", v)
		}
	}
}

[{Dune 1} {Emma 2}]
[{Dune 101} {Emma 102}]
{Dune 10} {Emma 20}
array range sees 3
slice range sees 99

package main

import "fmt"

func main() {
	// The range expression is evaluated once, before the loop begins, so
	// appending to the slice does not extend the iteration.
	s := []int{1, 2, 3}
	iterations := 0
	for _, v := range s {
		s = append(s, v*10)
		iterations++
	}
	fmt.Println(iterations, s)

	// Deleting from a map while ranging over it is safe: an entry removed
	// before it is reached is never produced.
	m := map[int]bool{1: true, 2: true, 3: true, 4: true}
	for k := range m {
		delete(m, k)
	}
	fmt.Println(len(m))

	// The same holds for clear.
	m2 := map[int]bool{1: true, 2: true}
	for range m2 {
		clear(m2)
	}
	fmt.Println(len(m2))

	// Entries added during iteration may or may not be visited; the count
	// below can differ from run to run, so only its bounds are meaningful.
	m3 := map[int]bool{0: true}
	visited := 0
	for k := range m3 {
		visited++
		if k < 50 {
			m3[k+100] = true
		}
	}
	fmt.Println(visited >= 1, visited <= len(m3))
}

3 [1 2 3 10 20 30]
0
0
true true

package main

import (
	"fmt"
	"iter"
	"slices"
)

type Book struct {
	Title string
	Year  int
}

type Shelf struct{ books []Book }

// All returns an iterator; the loop body becomes the yield function.
func (s *Shelf) All() iter.Seq2[int, Book] {
	return func(yield func(int, Book) bool) {
		for i, b := range s.books {
			if !yield(i, b) {
				return // the loop body executed break or return
			}
		}
	}
}

func (s *Shelf) Titles() iter.Seq[string] {
	return func(yield func(string) bool) {
		for _, b := range s.books {
			if !yield(b.Title) {
				return
			}
		}
	}
}

func find(s *Shelf, year int) (Book, bool) {
	for _, b := range s.All() {
		if b.Year == year {
			return b, true // return from inside the loop body works
		}
	}
	return Book{}, false
}

func main() {
	s := &Shelf{[]Book{{"Dune", 1965}, {"Emma", 1815}, {"Ulysses", 1922}}}
	for i, b := range s.All() {
		if i == 2 {
			break // stops the iterator
		}
		fmt.Println(i, b.Title)
	}
	fmt.Println(slices.Collect(s.Titles()))
	fmt.Println(find(s, 1922))
	for i := range slices.Backward(s.books) {
		fmt.Print(i, " ")
	}
	fmt.Println()
}

0 Dune
1 Emma
[Dune Emma Ulysses]
{Ulysses 1922} true
2 1 0

module example.com/new

go 1.27

package main

import "fmt"

func main() {
	// Closures capture the variable, not a value. Collect them, call later.
	var prints []func()
	for i := 1; i <= 3; i++ {
		prints = append(prints, func() { fmt.Print(i, " ") })
	}
	for _, p := range prints {
		p()
	}
	fmt.Println()

	// Same with range, and with pointers to the loop variable.
	var ptrs []*string
	for _, t := range []string{"Dune", "Emma", "Ulysses"} {
		ptrs = append(ptrs, &t)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()

	// Closures that modify their loop variable: with per-iteration
	// variables each closure owns its own counter.
	var fs []func() int
	for i := 0; i < 6; i += 2 {
		fs = append(fs, func() int { i++; return i })
	}
	for _, f := range fs {
		fmt.Print(f(), " ", f(), " | ")
	}
	fmt.Println()
}

1 2 3
Dune Emma Ulysses
1 2 | 3 4 | 5 6 |

module example.com/old

go 1.21

4 4 4
Ulysses Ulysses Ulysses
7 8 | 9 10 | 11 12 |

package main

import "fmt"

func main() {
	fmt.Println("new semantics (go.mod says go 1.27):")
	newSemantics()
	fmt.Println("old semantics (file has //go:build go1.21):")
	oldSemantics()
}

func newSemantics() {
	var fs []func()
	for i := 0; i < 3; i++ {
		fs = append(fs, func() { fmt.Print(i, " ") })
	}
	for _, f := range fs {
		f()
	}
	fmt.Println()
}

//go:build go1.21

package main

import "fmt"

func oldSemantics() {
	var fs []func()
	for i := 0; i < 3; i++ {
		fs = append(fs, func() { fmt.Print(i, " ") })
	}
	for _, f := range fs {
		f()
	}
	fmt.Println()
}

new semantics (go.mod says go 1.27):
0 1 2
old semantics (file has //go:build go1.21):
3 3 3

package main

import (
	"fmt"
	"slices"
	"sync"
)

func main() {
	var mu sync.Mutex
	var seen []string
	var wg sync.WaitGroup
	for _, v := range []string{"a", "b", "c"} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mu.Lock()
			seen = append(seen, v)
			mu.Unlock()
		}()
	}
	wg.Wait()
	slices.Sort(seen)
	fmt.Println(seen)
}

[a b c]

main.go:18:24: loop variable v captured by func literal

main.go:8:6: loop variable i now per-iteration, stack-allocated
main.go:18:9: loop variable t now per-iteration, heap-allocated
main.go:29:6: loop variable i now per-iteration, heap-allocated

package main

import "fmt"

func main() {
	var prints []func()
	for _, v := range []string{"a", "b"} {
		v := v // pre-1.22 defensive copy
		prints = append(prints, func() { fmt.Print(v, " ") })
	}
	for i := 0; i < 3; i++ {
		fmt.Print(i, " ")
	}
	for _, p := range prints {
		p()
	}
	fmt.Println()
}

@@ -5,10 +5,9 @@
 func main() {
 	var prints []func()
 	for _, v := range []string{"a", "b"} {
-		v := v // pre-1.22 defensive copy
 		prints = append(prints, func() { fmt.Print(v, " ") })
 	}
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		fmt.Print(i, " ")
 	}
 	for _, p := range prints {

package main

import "fmt"

func main() {
	n := 1
	switch n {
	case 1:
		fmt.Println("a")
	case 1:
		fmt.Println("b")
	case "x":
		fmt.Println("c")
	case 2:
		fmt.Println("d")
		fallthrough
	}
	switch {
	case n:
	}
	switch n {
	default:
	default:
	}
}

main.go:10:7: duplicate case 1 (constant of type int) in expression switch
	./main.go:8:7: previous case
main.go:12:7: cannot convert "x" (untyped string constant) to type int
main.go:16:3: cannot fallthrough final case in switch
main.go:19:7: invalid case n in switch on true (mismatched types int and bool)
main.go:23:2: multiple defaults (first at ./main.go:22:2)

package main

import (
	"errors"
	"fmt"
	"io"
)

type Book struct{ Title string }

func (b Book) String() string { return "Book(" + b.Title + ")" }

func describe(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case int, int64: // several types: x keeps the type of v (any)
		return fmt.Sprintf("integer %v (%T)", x, x)
	case string:
		return "string of length " + fmt.Sprint(len(x)) // x is a string here
	case Book:
		return "book titled " + x.Title
	case *Book:
		return "pointer to " + x.Title
	case fmt.Stringer: // an interface type: any dynamic type with String()
		return "stringer " + x.String()
	case error:
		return "error " + x.Error()
	case []int:
		return fmt.Sprint("slice of ", len(x))
	case func() int:
		return fmt.Sprint("func returning ", x())
	default:
		return fmt.Sprintf("other %T", x)
	}
}

func main() {
	vals := []any{nil, 3, int64(4), "dune", Book{"Emma"}, &Book{"Ulysses"},
		io.EOF, []int{1, 2}, func() int { return 9 }, 2.5, errors.New("boom")}
	for _, v := range vals {
		fmt.Println(describe(v))
	}
}

nil
integer 3 (int)
integer 4 (int64)
string of length 4
book titled Emma
pointer to Ulysses
error EOF
slice of 2
func returning 9
other float64
error boom

package main

import "fmt"

type Shape interface{ Area() float64 }

type Sq struct{}

func main() {
	var v any = 1
	switch x := v.(type) {
	case int:
		fmt.Println("int")
		fallthrough
	case string:
	}
	var s Shape
	switch s.(type) {
	case Sq:
	case int:
	}
	n := 3
	switch n.(type) {
	}
	switch v.(type) {
	case int:
	case int:
	}
}

main.go:11:9: x declared and not used
main.go:14:3: cannot fallthrough in type switch
main.go:19:7: impossible type switch case: Sq
	s (variable of interface type Shape) cannot have dynamic type Sq (missing method Area)
main.go:20:7: impossible type switch case: int
	s (variable of interface type Shape) cannot have dynamic type int (missing method Area)
main.go:23:9: n (variable of type int) is not an interface
main.go:27:7: duplicate case int in type switch
	./main.go:26:7: previous case

package main

import (
	"errors"
	"fmt"
)

var attempts int

func flaky() error {
	attempts++
	if attempts < 3 {
		return errors.New("try again")
	}
	return nil
}

func main() {
	// goto is legal and occasionally the clearest way to express retry or
	// shared cleanup. It may not jump over variable declarations in the same
	// block or into another block.
	var err error
retry:
	if err = flaky(); err != nil {
		fmt.Println("attempt", attempts, "failed:", err)
		goto retry
	}
	fmt.Println("succeeded after", attempts, "attempts")

	i := 0
loop:
	if i < 3 {
		fmt.Print(i, " ")
		i++
		goto loop
	}
	fmt.Println()
}

attempt 1 failed: try again
attempt 2 failed: try again
succeeded after 3 attempts
0 1 2

package main

import "fmt"

func main() {
	goto end
	v := 3
	fmt.Println(v)
end:
	fmt.Println("done")

	goto inside
	{
	inside:
		fmt.Println("inside")
	}
}

main.go:6:7: goto end jumps over declaration of v at ./main.go:7:4
main.go:12:7: goto inside jumps into block starting at ./main.go:13:2