Go continue Statement — Optimize¶

func processNumbers(nums []int) []int {
    result := make([]int, 0, len(nums)) // pre-allocate capacity
    for _, n := range nums {
        if n > 0 {
            result = append(result, n*2)
        }
        // no continue needed — loop naturally advances
    }
    return result
}

func processUsers(users []User) {
    for _, u := range users {
        if !u.IsActive { continue }
        if u.Age < 18 { continue }
        if u.Email == "" { continue }
        if u.Role == "banned" { continue }

        // Happy path — flat, readable
        sendWelcomeEmail(u)
        updateLastLogin(u)
        logEvent("user.processed", u.ID)
    }
}

func filterWords(words []string) []string {
    result := make([]string, 0, len(words))
    for _, w := range words {
        // Combine length bounds into one guard
        if len(w) < 3 || len(w) > 20 {
            continue
        }
        result = append(result, w)
    }
    return result
}

func processRow(i int, row []int) ([]int, bool) {
    if len(row) == 0 {
        fmt.Println("empty row at", i)
        return nil, false // false = skip this row
    }
    var results []int
    for j, val := range row {
        if val < 0 {
            fmt.Printf("negative at [%d,%d], skipping row\n", i, j)
            return nil, false // skip entire row
        }
        if val == 0 {
            fmt.Printf("zero at [%d,%d], skipping value\n", i, j)
            continue
        }
        results = append(results, val)
    }
    return results, true
}

func processMatrix(matrix [][]int) {
    var results []int
    for i, row := range matrix {
        rowResults, ok := processRow(i, row)
        if !ok {
            continue // clean, no label needed
        }
        results = append(results, rowResults...)
    }
    fmt.Println(results)
}

func filterAndTransform(data []Record) []Output {
    // Single pass: filter + transform together
    result := make([]Output, 0, len(data)) // pre-allocate with upper bound
    for _, r := range data {
        if !r.IsValid() {
            continue
        }
        result = append(result, transform(r))
    }
    return result
}

// Generic filter — reusable, testable
func Filter[T any](s []T, keep func(T) bool) []T {
    result := make([]T, 0, len(s))
    for _, v := range s {
        if !keep(v) {
            continue
        }
        result = append(result, v)
    }
    return result
}

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

func getActiveUserIDs(users []User) []int {
    activeUsers := Filter(users, func(u User) bool {
        return u.IsActive && u.ID != 0
    })
    return Map(activeUsers, func(u User) int { return u.ID })
}

// When to use inline continue instead (simpler cases):
func getActiveUserIDsSimple(users []User) []int {
    ids := make([]int, 0, len(users))
    for _, u := range users {
        if !u.IsActive || u.ID == 0 { continue }
        ids = append(ids, u.ID)
    }
    return ids
}

// Option 1: End span explicitly before each continue
func processItems(ctx context.Context, items []Item) {
    for _, item := range items {
        span := startSpan(ctx, "process.item")

        if !item.IsReady() {
            endSpan(span) // end before continue
            continue
        }
        if item.Value < 0 {
            endSpan(span) // end before continue
            continue
        }

        process(item)
        endSpan(span)
    }
}

// Option 2 (preferred): Extract to function, use defer
func processItems(ctx context.Context, items []Item) {
    for _, item := range items {
        processOne(ctx, item)
    }
}

func processOne(ctx context.Context, item Item) {
    span := startSpan(ctx, "process.item")
    defer endSpan(span) // always ends

    if !item.IsReady() {
        return // defer runs
    }
    if item.Value < 0 {
        return // defer runs
    }

    process(item)
}

// Reorder conditions: cheapest + most frequently skipping first
func sumFiltered(data []int32) int64 {
    var sum int64
    for _, v := range data {
        // Most selective + cheapest check first
        // If 80% pass, "most frequently skipping" means:
        // - Order by: (fraction that triggers continue) descending
        // - Also order by: (cost of check) ascending for ties

        // Assume: v%7 == 0 is least common (~14% skip)
        //         v < 0 is medium (~10% skip)
        //         v > 1000 is most common skip (~30% skip based on data)
        // So order: most common skip first

        if v > 1000 { continue }  // cheap comparison, ~30% skip
        if v < 0 { continue }     // cheap comparison, ~10% skip
        if v%7 == 0 { continue }  // modulo is slower, ~14% skip
        sum += int64(v)
    }
    return sum
}

// Branchless alternative for SIMD-friendly code:
func sumFilteredBranchless(data []int32) int64 {
    var sum int64
    for _, v := range data {
        // All conditions in one expression — may auto-vectorize
        if v >= 0 && v <= 1000 && v%7 != 0 {
            sum += int64(v)
        }
    }
    return sum
}

// Benchmark to verify:
// go test -bench=BenchmarkSumFiltered -benchmem -count=5

// SoA (Struct of Arrays) — separates hot data from cold data
type Records struct {
    IDs      []int64
    IsActive []bool    // hot: checked in every iteration
    Scores   []float64 // warm: checked for active records
    Metadata [][256]byte // cold: only needed for processing
}

func sumActiveScores(records *Records) float64 {
    var total float64
    // Only IsActive and Scores are in hot cache lines
    for i, active := range records.IsActive {
        if !active {
            continue // cache miss only for IsActive — 1 byte per record
        }
        if records.Scores[i] < 0 {
            continue
        }
        total += records.Scores[i]
        // records.Metadata[i] is only accessed if needed, not here
    }
    return total
}

// Benchmark comparison:
// AoS: each iteration loads 272+ bytes (full Record) for the IsActive check
// SoA: each iteration loads 1 byte (IsActive), 64 cache lines cover 64 records
// For large record counts with many skips: SoA can be 10-50x faster due to cache efficiency

// Branchless version — eligible for auto-vectorization
func addPositive(a, b []float32, result []float32) {
    n := len(result)
    if len(a) < n { n = len(a) }
    if len(b) < n { n = len(b) }

    for i := 0; i < n; i++ {
        // Branchless max(x, 0): if x > 0, use x; else 0
        // This avoids the conditional branch
        av := a[i]
        bv := b[i]
        // Both must be positive; otherwise result is 0
        // pos(x) = x * (x > 0 ? 1 : 0) — compiled to conditional move (CMOV)
        var aPos, bPos float32
        if av > 0 { aPos = av }
        if bv > 0 { bPos = bv }
        // If either was ≤0, aPos or bPos is 0, so product-based masking:
        if aPos > 0 && bPos > 0 {
            result[i] = aPos + bPos
        }
        // else result[i] = 0 (zero-initialized)
    }
}

// True branchless (relies on compiler generating CMOV, not conditional jump):
func addPositiveBranchless(a, b []float32, result []float32) {
    for i := range result {
        sum := a[i] + b[i]
        // If either is non-positive, zero out the result
        mask := float32(1.0)
        if a[i] <= 0 { mask = 0 }
        if b[i] <= 0 { mask = 0 }
        result[i] = sum * mask
    }
}

// Verify auto-vectorization:
// go build -gcflags="-d=ssa/check_bce/debug=1" ./...
// or check assembly for VADDPS / VMULPS (AVX) instructions

func processAll(ctx context.Context, items []Item) []Result {
    // Pre-filter: don't spawn goroutines for items that will be skipped
    ready := make([]Item, 0, len(items))
    for _, item := range items {
        if !item.IsReady() {
            continue // filter before goroutine creation
        }
        ready = append(ready, item)
    }

    if len(ready) == 0 {
        return nil
    }

    resultCh := make(chan Result, len(ready))
    var wg sync.WaitGroup

    for _, item := range ready {
        wg.Add(1)
        go func(it Item) {
            defer wg.Done()
            resultCh <- process(ctx, it)
        }(item)
    }

    wg.Wait()
    close(resultCh)

    results := make([]Result, 0, len(ready))
    for r := range resultCh {
        results = append(results, r)
    }
    return results
}