06 — Control Flow

type State int
const (
    StateIdle State = iota
    StateConnecting
    StateConnected
    StateReconnecting
    StateError
)

type Event int
const (
    EventConnect Event = iota
    EventConnected
    EventDisconnect
    EventError
    EventRetry
)

// transition table — pure function, easy to test
func transition(s State, e Event) (State, error) {
    switch s {
    case StateIdle:
        switch e {
        case EventConnect:
            return StateConnecting, nil
        default:
            return s, fmt.Errorf("illegal event %d in state Idle", e)
        }
    case StateConnecting:
        switch e {
        case EventConnected:
            return StateConnected, nil
        case EventError:
            return StateError, nil
        case EventDisconnect:
            return StateIdle, nil
        default:
            return s, fmt.Errorf("illegal event %d in state Connecting", e)
        }
    case StateConnected:
        switch e {
        case EventDisconnect:
            return StateIdle, nil
        case EventError:
            return StateReconnecting, nil
        default:
            return s, fmt.Errorf("illegal event %d in state Connected", e)
        }
    case StateReconnecting:
        switch e {
        case EventConnected:
            return StateConnected, nil
        case EventError:
            return StateError, nil
        default:
            return s, fmt.Errorf("illegal event %d in state Reconnecting", e)
        }
    case StateError:
        switch e {
        case EventRetry:
            return StateConnecting, nil
        default:
            return s, fmt.Errorf("illegal event %d in state Error", e)
        }
    default:
        return s, fmt.Errorf("unknown state %d", s)
    }
}

💡 Tips & Tricks

• Idiom: if init; condition keeps temporary variables scoped to the block — if err := f(); err != nil signals "err is only for this check." This is the Go equivalent of try-catch's local error scope.
• Idiom: switch with no expression (switch { case x < 0: ... }) is cleaner than long if/else if chains — each case has its own condition, and the compiler generates a jump table when possible.
• Idiom: for i := range n (Go 1.22+) is the cleanest simple count loop — no off-by-one, no < vs <= confusion. Use for any "do this N times" loop.
• Performance: range over a slice copies the element value into the loop variable — for large structs, use index access (for i := range s { s[i].field }) to avoid copying. Or range over a slice of pointers.
• Idiom: labeled break for nested-loop exits — break outer is the clean way to exit from deep inside nested loops. The alternative (flags like found := true; break) is less readable.
• Idiom: for-select with a done channel and break loop is the standard concurrent event-loop pattern — the label is needed because break alone only exits the select, not the for.

⚠️ Edge Cases & Gotchas

• Braces mandatory, same-line: if x\n{ is a syntax error (ASI inserts a semicolon after x). The opening brace must be on the same line as if/for/func.
• switch doesn't fall through by default: unlike C/Java, each case ends without break. fallthrough is explicit and jumps to the next case's body unconditionally (doesn't check the next case's value).
• range over a string yields byte offsets: for i, r := range "café" gives i=0,2,3,4 (not 0,1,2,3) because 'a' is 1 byte but 'é' is 2 bytes — the index is the byte position, not the character index.
• range over a map is randomized: iteration order is intentionally shuffled each run. Never depend on map iteration order — sort keys explicitly.
• Modifying a slice during range: for i, v := range s { s = append(s, v) } — range captured len(s) at loop start, so appended elements aren't iterated. Modifying existing elements (s[i] = ...) works fine.
• range copies the element: for _, v := range largeSlice copies each element into v. For large structs, use for i := range s { v := &s[i] } to avoid copies.
• continue in a select inside a for: continue applies to the enclosing for, not the select. This is correct but surprising.
• default in a for-select causes busy-spin: without a blocking case or a time.Sleep, the loop spins at 100% CPU. Only use default when you genuinely want non-blocking polling.
• goto can't jump over variable declarations: goto end; x := 5; end: is a compile error. goto is restricted to prevent scope violations.
• Go 1.22 loop scoping is controlled by go.mod: go 1.22 in go.mod enables per-iteration loop variables. go 1.21 keeps old semantics even on a 1.22+ compiler. The go directive is a language version selector, not just a minimum.
• for i := range -1 (Go 1.22+): negative integers cause a runtime panic ("range clause: negative range value"). Always validate before ranging over a computed integer.

🧠 Quick Quiz

s := []int{1, 2, 3}
for i, v := range s {
    s = append(s, v*10)
    fmt.Printf("i=%d v=%d len=%d\n", i, v, len(s))
}
fmt.Println(s)