for range — Professional Level (Internals, Compiler, Memory, Assembly)¶

// go/ast package (simplified)
type RangeStmt struct {
    For        token.Pos   // position of "for" keyword
    Key        Expr        // Key = first variable (may be nil)
    Value      Expr        // Value = second variable (may be nil)
    TokPos     token.Pos   // position of Tok
    Tok        token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE
    X          Expr        // value to range over
    Body       *BlockStmt
}

package main

func sumSlice(s []int) int {
    sum := 0
    for _, v := range s {
        sum += v
    }
    return sum
}

// runtime/map.go (Go source, simplified)
type hiter struct {
    key         unsafe.Pointer  // pointer to current key
    elem        unsafe.Pointer  // pointer to current value
    t           *maptype
    h           *hmap
    buckets     unsafe.Pointer  // starting bucket
    bptr        *bmap           // current bucket
    overflow    *[]*bmap
    oldoverflow *[]*bmap
    startBucket uintptr         // bucket iteration started at
    offset      uint8           // intra-bucket offset
    wrapped     bool            // already wrapped around
    B           uint8
    i           uint8
    bucket      uintptr
    checkBucket uintptr
}

func mapiterinit(t *maptype, h *hmap, it *hiter) {
    // ...
    // Randomize starting bucket using fastrand
    r := uintptr(fastrand())
    it.startBucket = r & bucketMask(h.B)
    it.offset = uint8(r >> h.B & (bucketCnt - 1))
    // ...
}

// for i, r := range s { ... }
// Compiler generates approximately:
{
    _s := s
    _i := 0
    for _i < len(_s) {
        i := _i
        var r rune
        if _s[_i] < utf8.RuneSelf {
            r = rune(_s[_i])
            _i++
        } else {
            r, _size := utf8.DecodeRuneInString(_s[_i:])
            _i += _size
        }
        // loop body with i and r
    }
}

// for v := range ch { use(v) }
// Desugars to:
for {
    v, ok := <-ch  // calls runtime.chanrecv
    if !ok { break }
    use(v)
}

// runtime/chan.go
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
    // If channel is nil and block=true: goroutine parks forever
    // If channel is empty and closed: return zero value, received=false
    // If channel is empty and open: park goroutine (block=true)
    // If channel has data: copy from buffer or sender
}

// for i := range n { use(i) }
// Desugars to:
for i := 0; i < n; i++ {
    use(i)
}

// No allocation cases:
for i, v := range []int{1, 2, 3} { _ = i; _ = v }  // literal: may allocate once for literal
for k, v := range m { _, _ = k, v }                  // no alloc (map allocs pre-exist)
for i, r := range "hello" { _, _ = i, r }             // no alloc (string is immutable)
for v := range ch { _ = v }                           // no alloc (receives in place)

// The hiter struct for map range lives on the stack (if not too large)
// Stack allocation is elided by the compiler when the iterator doesn't escape

package main

// BCE demo
func copy1(dst, src []int) {
    // NOT BCE-optimal: independent bound checks
    for i := 0; i < len(src); i++ {
        dst[i] = src[i] // two bounds checks per iteration
    }
}

func copy2(dst, src []int) {
    // BCE-optimal: range gives compiler proof that i ∈ [0, len(src))
    // The dst[i] still requires a check unless dst is proven same length
    for i, v := range src {
        dst[i] = v
    }
}

func copy3(dst, src []int) {
    // Fully BCE: hint compiler that dst is large enough
    dst = dst[:len(src)] // compiler now knows dst[i] is safe for i in src range
    for i, v := range src {
        dst[i] = v // no bounds checks!
    }
}

func rangeWithLargeLocal(s []int) {
    for _, v := range s {
        var buf [4096]byte  // 4KB local — may trigger stack growth
        process(buf[:], v)
    }
}

package main

import (
    "context"
    "runtime/trace"
)

func processWithTrace(ctx context.Context, items []int) {
    ctx, task := trace.NewTask(ctx, "processItems")
    defer task.End()

    for i, item := range items {
        region := trace.StartRegion(ctx, "item")
        heavyProcess(i, item)
        region.End()
    }
}

// Small functions called inside range are inlined by the compiler
func double(x int) int { return x * 2 } // will be inlined

func main() {
    s := []int{1, 2, 3}
    for i, v := range s {
        s[i] = double(v) // double() inlined — no function call overhead
    }
}

package main

import (
    "fmt"
    "reflect"
)

func reflectRange(v interface{}) {
    rv := reflect.ValueOf(v)
    switch rv.Kind() {
    case reflect.Slice, reflect.Array:
        for i := 0; i < rv.Len(); i++ {
            fmt.Println(i, rv.Index(i).Interface())
        }
    case reflect.Map:
        for _, k := range rv.MapKeys() {
            fmt.Println(k.Interface(), rv.MapIndex(k).Interface())
        }
    case reflect.String:
        s := rv.String()
        for i, r := range s {
            fmt.Println(i, r)
        }
    }
}

func main() {
    reflectRange([]int{1, 2, 3})
}