Patrones de Iterador en Go 1.24: 7 Patrones de Producción desde Range Over Func hasta Pipelines de Datos

Cuando los bucles for se encuentran con funciones: el cambio de paradigma de iteradores en Go

La semana pasada refactoricé un servicio de procesamiento de datos con 3 niveles de bucles for anidados manejando 100K registros — la memoria se disparó a 2GB porque cada nivel tenía que almacenar resultados intermedios como slices antes de pasar al siguiente. Después de cambiar a un pipeline de iteradores, la memoria bajó a 15MB y el procesamiento fue 30% más rápido. El cambio clave: ya no más "recopilar y luego procesar" — en su lugar "iterar y procesar al vuelo".

Go 1.24 estabilizó oficialmente la sintaxis range over func y el paquete iter, dando a Go iteradores nativos, sin asignación de memoria y componibles. Esto no es azúcar sintáctico — es un cambio fundamental en los paradigmas de procesamiento de datos. Este artículo cubre 7 patrones de iteradores Go de grado de producción para ayudarte a construir pipelines de datos eficientes, elegantes y componibles.

Puntos Clave

range over func es la sintaxis central de iteradores: Go 1.24 permite iterar sobre funciones directamente
Conversión de iteradores Push/Pull: Comprende ambas direcciones, domina la conversión con iter.Pull
Composición de pipelines de datos: Composición en cadena Map/Filter/Reduce con cero asignación intermedia
Evaluación diferida y secuencias infinitas: Calcula bajo demanda, procesa flujos de datos infinitos
Iteradores concurrentes y Fan-out: Múltiples goroutines consumiendo iteradores en paralelo
Manejo de errores en iteradores: Maneja errores elegantemente durante la iteración
Diseño de biblioteca de iteradores de grado de producción: Construye toolkits de iteradores reutilizables

Tabla de Contenidos

Referencia de Conceptos Core de Iteradores en Go
Patrón 1: Iterador Básico range over func
Patrón 2: Conversión de Iteradores Push/Pull
Patrón 3: Composición de Pipeline de Datos (Map/Filter/Reduce)
Patrón 4: Evaluación Diferida y Secuencias Infinitas
Patrón 5: Iteradores Concurrentes y Fan-out
Patrón 6: Manejo de Errores en Iteradores
Patrón 7: Diseño de Biblioteca de Iteradores de Grado de Producción
5 Errores Comunes y Soluciones
10 Soluciones a Errores Comunes
Consejos Avanzados de Optimización
Análisis Comparativo: Iteradores vs Canales vs Slices
Herramientas en Línea Recomendadas
Resumen

Referencia de Conceptos Core de Iteradores en Go

Concepto	Firma	Propósito	Ejemplo
Función iteradora	`func(yield func(V) bool)`	Iterador de valor único	`func(yield func(int) bool)`
Iterador clave-valor	`func(yield func(K, V) bool)`	Iteración de pares clave-valor	`func(yield func(int, string) bool)`
Iterador Pull	`func() (V, bool)`	Extracción bajo demanda	`next, stop := iter.Pull(seq)`
iter.Pull	`func(Seq[V]) (func() (V, bool), func())`	Conversión de Push a Pull	Recorrido controlado por el consumidor
iter.Stop	Función de parada integrada	Terminación anticipada	`stop()` libera recursos
Valor de retorno de yield	`bool`	Controlar continuar/detener iteración	`yield(v)` devuelve false para detener
Evaluación diferida	Cómputo diferido	Generar valores bajo demanda	Secuencias infinitas, líneas de archivo
Composición de pipeline	Encadenamiento de funciones	Cero asignación intermedia	`Filter(Map(Seq, fn), pred)`

Patrón 1: Iterador Básico range over func

Problema: Trampas de Memoria del Recorrido Tradicional

func GetAllUsers(db *sql.DB) ([]User, error) {
    rows, err := db.Query("SELECT id, name, email FROM users")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, rows.Err()
}

1 millón de usuarios? 1 millón de structs User cargados en memoria. Solo necesitas los primeros 10? Malas noticias — cárgalos todos primero.

Solución: Iterador range over func

package iterator

import (
    "database/sql"
    "iter"
)

type User struct {
    ID    int
    Name  string
    Email string
}

func AllUsers(db *sql.DB) iter.Seq2[int, User] {
    return func(yield func(int, User) bool) {
        rows, err := db.Query("SELECT id, name, email FROM users")
        if err != nil {
            return
        }
        defer rows.Close()

        i := 0
        for rows.Next() {
            var u User
            if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
                return
            }
            if !yield(i, u) {
                return
            }
            i++
        }
    }
}

Uso:

for i, user := range AllUsers(db) {
    fmt.Printf("%d: %s\n", i, user.Name)
    if i >= 9 {
        break
    }
}

Cuando se ejecuta break, yield devuelve false, y la función iteradora retorna inmediatamente — solo 10 filas consultadas, conexión a la base de datos correctamente cerrada.

Flujo de Ejecución del Iterador

┌─────────────┐     yield(v)      ┌──────────────┐
│  Iterador    │ ──────────────→  │  bucle range  │
│  (productor) │                   │  (consumidor) │
│              │  ←──────────────  │               │
│              │   yield devuelve  │               │
│              │      bool         │               │
└─────────────┘                   └──────────────┘
      │                                  │
      │  yield devuelve false → return   │
      │  (terminación anticipada)        │
      └──────────────────────────────────┘

Iterador de Valor Único vs Clave-Valor

type IntSlice []int

func (s IntSlice) Values() iter.Seq[int] {
    return func(yield func(int) bool) {
        for _, v := range s {
            if !yield(v) {
                return
            }
        }
    }
}

func (s IntSlice) All() iter.Seq2[int, int] {
    return func(yield func(int, int) bool) {
        for i, v := range s {
            if !yield(i, v) {
                return
            }
        }
    }
}

nums := IntSlice{10, 20, 30}

for v := range nums.Values() {
    fmt.Println(v)
}

for i, v := range nums.All() {
    fmt.Printf("index=%d value=%d\n", i, v)
}

Patrón 2: Conversión de Iteradores Push/Pull

Diferencias entre Iteradores Push y Pull

Iterador Push (iter.Seq)            Iterador Pull (func() (V, bool))
┌──────────────────┐               ┌──────────────────┐
│  Productor empuja │               │  Consumidor tira  │
│  yield(v) → cons. │               │  next() → prod.   │
│                    │               │                    │
│  Bueno para: range │               │  Bueno para: manual│
│  Bueno para: pipes │               │  Bueno para: peek  │
│  Bueno para: lazy  │               │  Bueno para: interop│
└──────────────────┘               └──────────────────┘
         │                                  │
         │      conversión iter.Pull()      │
         └──────────────────────────────────┘

Usando la Conversión iter.Pull

package main

import (
    "fmt"
    "iter"
)

func Countdown(n int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := n; i > 0; i-- {
            if !yield(i) {
                return
            }
        }
    }
}

func main() {
    next, stop := iter.Pull(Countdown(5))
    defer stop()

    for {
        v, ok := next()
        if !ok {
            break
        }
        fmt.Println(v)
        if v == 3 {
            fmt.Println("Terminación anticipada")
            break
        }
    }
}

Aplicaciones Prácticas de Iteradores Pull: Peek y Take

package iterutil

import "iter"

func Take[V any](seq iter.Seq[V], n int) iter.Seq[V] {
    return func(yield func(V) bool) {
        count := 0
        for v := range seq {
            if count >= n {
                return
            }
            if !yield(v) {
                return
            }
            count++
        }
    }
}

func First[V any](seq iter.Seq[V]) (V, bool) {
    next, stop := iter.Pull(seq)
    defer stop()
    return next()
}

func PeekN[V any](seq iter.Seq[V], n int) []V {
    result := make([]V, 0, n)
    next, stop := iter.Pull(seq)
    defer stop()

    for i := 0; i < n; i++ {
        v, ok := next()
        if !ok {
            break
        }
        result = append(result, v)
    }
    return result
}

nums := Countdown(100)
fmt.Println(First(nums))
fmt.Println(PeekN(nums, 5))

Importante: Limpieza de Recursos con iter.Pull

func ProcessLines(filename string) iter.Seq[string] {
    return func(yield func(string) bool) {
        file, err := os.Open(filename)
        if err != nil {
            return
        }
        defer file.Close()

        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            if !yield(scanner.Text()) {
                return
            }
        }
    }
}

func main() {
    next, stop := iter.Pull(ProcessLines("huge.log"))
    defer stop()

    v, ok := next()
    if ok {
        fmt.Println("Primera línea:", v)
    }
}

defer stop() asegura que el archivo se cierre correctamente incluso si solo se consume un valor.

Patrón 3: Composición de Pipeline de Datos (Map/Filter/Reduce)

Problema: Bucles Anidados y Slices Intermedios

func ProcessOrders(orders []Order) float64 {
    var active []Order
    for _, o := range orders {
        if o.Status == "active" {
            active = append(active, o)
        }
    }

    var amounts []float64
    for _, o := range active {
        amounts = append(amounts, o.Amount*1.1)
    }

    var total float64
    for _, a := range amounts {
        total += a
    }
    return total
}

3 recorridos, 2 slices intermedios. Con conjuntos de datos grandes, la presión de memoria y GC es significativa.

Solución: Pipeline de Iteradores

package pipeline

import "iter"

func Map[V any, U any](seq iter.Seq[V], fn func(V) U) iter.Seq[U] {
    return func(yield func(U) bool) {
        for v := range seq {
            if !yield(fn(v)) {
                return
            }
        }
    }
}

func Map2[K any, V any, U any](seq iter.Seq2[K, V], fn func(K, V) U) iter.Seq[U] {
    return func(yield func(U) bool) {
        for k, v := range seq {
            if !yield(fn(k, v)) {
                return
            }
        }
    }
}

func Filter[V any](seq iter.Seq[V], pred func(V) bool) iter.Seq[V] {
    return func(yield func(V) bool) {
        for v := range seq {
            if pred(v) {
                if !yield(v) {
                    return
                }
            }
        }
    }
}

func Filter2[K any, V any](seq iter.Seq2[K, V], pred func(K, V) bool) iter.Seq2[K, V] {
    return func(yield func(K, V) bool) {
        for k, v := range seq {
            if pred(k, v) {
                if !yield(k, v) {
                    return
                }
            }
        }
    }
}

func Reduce[V any, U any](seq iter.Seq[V], init U, fn func(U, V) U) U {
    acc := init
    for v := range seq {
        acc = fn(acc, v)
    }
    return acc
}

Usando Composición de Pipeline

type Order struct {
    ID     int
    Status string
    Amount float64
}

func OrdersFromDB(db *sql.DB) iter.Seq[Order] {
    return func(yield func(Order) bool) {
        rows, _ := db.Query("SELECT id, status, amount FROM orders")
        if rows != nil {
            defer rows.Close()
            for rows.Next() {
                var o Order
                rows.Scan(&o.ID, &o.Status, &o.Amount)
                if !yield(o) {
                    return
                }
            }
        }
    }
}

func main() {
    db, _ := sql.Open("postgres", "dsn")

    total := Reduce(
        Map(
            Filter(
                OrdersFromDB(db),
                func(o Order) bool { return o.Status == "active" },
            ),
            func(o Order) float64 { return o.Amount * 1.1 },
        ),
        0.0,
        func(acc float64, v float64) float64 { return acc + v },
    )

    fmt.Printf("Total: %.2f\n", total)
}

Cero asignación intermedia: Filter, Map y Reduce están encadenados — cada elemento se procesa exactamente una vez.

Flujo de Ejecución del Pipeline

OrdersFromDB → Filter(active) → Map(×1.1) → Reduce(+) → total
     │              │                │            │
     │  Order{1,    │  Status==      │  Amount*1.1 │  acc+v
     │  "active",   │  "active"?     │             │
     │  100.0}      │                │             │
     │      ──────→ │  ✓ pasa        │             │
     │              │      ──────→   │  110.0      │
     │              │                │   ──────→   │  110.0
     │
     │  Order{2,    │  Status!=      │             │
     │  "closed",   │  "active"      │             │
     │  200.0}      │  ✗ filtrado    │             │
     │      ──────→ │  omitir        │             │

Más Operadores de Pipeline

func FlatMap[V any, U any](seq iter.Seq[V], fn func(V) iter.Seq[U]) iter.Seq[U] {
    return func(yield func(U) bool) {
        for v := range seq {
            for u := range fn(v) {
                if !yield(u) {
                    return
                }
            }
        }
    }
}

func Zip[V any, U any](seq1 iter.Seq[V], seq2 iter.Seq[U]) iter.Seq2[V, U] {
    return func(yield func(V, U) bool) {
        next1, stop1 := iter.Pull(seq1)
        defer stop1()
        next2, stop2 := iter.Pull(seq2)
        defer stop2()

        for {
            v1, ok1 := next1()
            v2, ok2 := next2()
            if !ok1 || !ok2 {
                return
            }
            if !yield(v1, v2) {
                return
            }
        }
    }
}

func Enumerate[V any](seq iter.Seq[V]) iter.Seq2[int, V] {
    return func(yield func(int, V) bool) {
        i := 0
        for v := range seq {
            if !yield(i, v) {
                return
            }
            i++
        }
    }
}

func Chunk[V any](seq iter.Seq[V], size int) iter.Seq[[]V] {
    return func(yield func([]V) bool) {
        chunk := make([]V, 0, size)
        for v := range seq {
            chunk = append(chunk, v)
            if len(chunk) == size {
                if !yield(chunk) {
                    return
                }
                chunk = make([]V, 0, size)
            }
        }
        if len(chunk) > 0 {
            yield(chunk)
        }
    }
}

Patrón 4: Evaluación Diferida y Secuencias Infinitas

Problema: Desperdicio de Pre-calcular Todos los Resultados

func Fibonacci(n int) []int {
    result := make([]int, n)
    if n > 0 {
        result[0] = 0
    }
    if n > 1 {
        result[1] = 1
    }
    for i := 2; i < n; i++ {
        result[i] = result[i-1] + result[i-2]
    }
    return result
}

Necesitas los primeros 10 números de Fibonacci? Debes especificar n. No sabes cuántos? Calcula un valor "suficientemente grande" por adelantado.

Solución: Iterador Infinito + Evaluación Diferida

package lazy

import "iter"

func Fibonacci() iter.Seq[int] {
    return func(yield func(int) bool) {
        a, b := 0, 1
        for {
            if !yield(a) {
                return
            }
            a, b = b, a+b
        }
    }
}

func NaturalNumbers() iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := 0; ; i++ {
            if !yield(i) {
                return
            }
        }
    }
}

func Repeat[V any](v V) iter.Seq[V] {
    return func(yield func(V) bool) {
        for {
            if !yield(v) {
                return
            }
        }
    }
}

func Iterate[V any](init V, fn func(V) V) iter.Seq[V] {
    return func(yield func(V) bool) {
        v := init
        for {
            if !yield(v) {
                return
            }
            v = fn(v)
        }
    }
}

func Cycle[V any](seq iter.Seq[V]) iter.Seq[V] {
    return func(yield func(V) bool) {
        for {
            for v := range seq {
                if !yield(v) {
                    return
                }
            }
        }
    }
}

Usando Secuencias Diferidas

func main() {
    for v := range Take(Fibonacci(), 10) {
        fmt.Print(v, " ")
    }
    fmt.Println()

    squares := Map(
        Take(NaturalNumbers(), 5),
        func(n int) int { return n * n },
    )
    for v := range squares {
        fmt.Print(v, " ")
    }
    fmt.Println()

    powersOf2 := Iterate(1, func(v int) int { return v * 2 })
    for v := range Take(powersOf2, 8) {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

Procesamiento Diferido de Archivos

func FileLines(path string) iter.Seq[string] {
    return func(yield func(string) bool) {
        f, err := os.Open(path)
        if err != nil {
            return
        }
        defer f.Close()

        scanner := bufio.NewScanner(f)
        for scanner.Scan() {
            if !yield(scanner.Text()) {
                return
            }
        }
    }
}

func Grep(pattern string, lines iter.Seq[string]) iter.Seq[string] {
    re := regexp.MustCompile(pattern)
    return Filter(lines, func(line string) bool {
        return re.MatchString(line)
    })
}

func main() {
    errors := Grep("ERROR", FileLines("/var/log/app.log"))
    for line := range Take(errors, 100) {
        fmt.Println(line)
    }
}

Archivo de log de 10GB? Solo lee las primeras 100 líneas con ERROR — uso de memoria cercano a cero.

Patrón 5: Iteradores Concurrentes y Fan-out

Problema: Cuello de Botella de Rendimiento del Iterador de un Solo Hilo

func ProcessImages(images iter.Seq[Image]) []Result {
    var results []Result
    for img := range images {
        r := expensiveTransform(img)
        results = append(results, r)
    }
    return results
}

1000 imágenes, 100ms cada una, total 100 segundos. Utilización de CPU solo 12.5% (1 de 8 núcleos usados).

Solución: Iterador Concurrente Fan-out

package concurrent

import (
    "iter"
    "sync"
)

func FanOut[V any, U any](seq iter.Seq[V], workers int, fn func(V) U) iter.Seq[U] {
    return func(yield func(U) bool) {
        inputCh := make(chan V)
        outputCh := make(chan U)

        var wg sync.WaitGroup
        for i := 0; i < workers; i++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                for v := range inputCh {
                    outputCh <- fn(v)
                }
            }()
        }

        go func() {
            for v := range seq {
                inputCh <- v
            }
            close(inputCh)
            wg.Wait()
            close(outputCh)
        }()

        for u := range outputCh {
            if !yield(u) {
                return
            }
        }
    }
}

func FanOutOrdered[V any, U any](seq iter.Seq[V], workers int, fn func(V) U) iter.Seq[U] {
    return func(yield func(U) bool) {
        type indexedResult struct {
            index int
            value U
        }

        next, stop := iter.Pull(seq)
        defer stop()

        type indexedInput[V any] struct {
            index int
            value V
        }

        inputCh := make(chan indexedInput[V], workers)
        outputCh := make(chan indexedResult, workers)

        var wg sync.WaitGroup
        for i := 0; i < workers; i++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                for inp := range inputCh {
                    outputCh <- indexedResult{
                        index: inp.index,
                        value: fn(inp.value),
                    }
                }
            }()
        }

        go func() {
            idx := 0
            for {
                v, ok := next()
                if !ok {
                    break
                }
                inputCh <- indexedInput[V]{index: idx, value: v}
                idx++
            }
            close(inputCh)
            wg.Wait()
            close(outputCh)
        }()

        results := make(map[int]U)
        nextIdx := 0
        for res := range outputCh {
            results[res.index] = res.value
            for {
                r, ok := results[nextIdx]
                if !ok {
                    break
                }
                delete(results, nextIdx)
                if !yield(r) {
                    return
                }
                nextIdx++
            }
        }
    }
}

Usando Iteradores Concurrentes

type Image struct {
    Path string
    Data []byte
}

type Result struct {
    Path      string
    Thumbnail []byte
}

func LoadImages(paths iter.Seq[string]) iter.Seq[Image] {
    return Map(paths, func(p string) Image {
        data, _ := os.ReadFile(p)
        return Image{Path: p, Data: data}
    })
}

func expensiveTransform(img Image) Result {
    thumbnail := resizeImage(img.Data, 100, 100)
    return Result{Path: img.Path, Thumbnail: thumbnail}
}

func main() {
    paths := SliceIterator([]string{"a.jpg", "b.jpg", "c.jpg"})

    results := FanOut(
        LoadImages(paths),
        runtime.NumCPU(),
        expensiveTransform,
    )

    for r := range results {
        fmt.Printf("Listo: %s\n", r.Path)
    }
}

Arquitectura de Iterador Concurrente

               ┌──────────┐
               │ Seq[V]   │
               │ (fuente) │
               └────┬─────┘
                    │
              ┌─────▼─────┐
              │ inputCh   │
              └─────┬─────┘
                    │
        ┌───────────┼───────────┐
        │           │           │
   ┌────▼───┐  ┌───▼────┐  ┌──▼─────┐
   │Worker 1│  │Worker 2│  │Worker N│
   │ fn(v)  │  │ fn(v)  │  │ fn(v)  │
   └────┬───┘  └───┬────┘  └──┬─────┘
        │          │          │
        └───────────┼──────────┘
                    │
              ┌─────▼─────┐
              │ outputCh  │
              └─────┬─────┘
                    │
              ┌─────▼─────┐
              │ yield(U)  │
              │(consumidor)│
              └───────────┘

Patrón 6: Manejo de Errores en Iteradores

Problema: Errores Ignorados en Iteradores

func ReadRecords(path string) iter.Seq[Record] {
    return func(yield func(Record) bool) {
        file, _ := os.Open(path)
        defer file.Close()

        decoder := json.NewDecoder(file)
        for decoder.More() {
            var r Record
            if err := decoder.Decode(&r); err != nil {
                return
            }
            if !yield(r) {
                return
            }
        }
    }
}

Cuando decoder.Decode falla, el error se pierde completamente. El llamador no puede distinguir si la iteración terminó normalmente o debido a un error.

Solución: Iteradores con Propagación de Errores

package itererr

import "iter"

type Result[V any] struct {
    Value V
    Err   error
}

func SeqWithError[V any](seq iter.Seq[Result[V]]) (iter.Seq[V], *error) {
    var firstErr error
    values := func(yield func(V) bool) {
        for r := range seq {
            if r.Err != nil {
                if firstErr == nil {
                    firstErr = r.Err
                }
                return
            }
            if !yield(r.Value) {
                return
            }
        }
    }
    return values, &firstErr
}

func Wrap[V any](seq iter.Seq[V], errPtr *error) iter.Seq[Result[V]] {
    return func(yield func(Result[V]) bool) {
        for v := range seq {
            if *errPtr != nil {
                return
            }
            if !yield(Result[V]{Value: v}) {
                return
            }
        }
    }
}

Aplicación Práctica: Iterador de Filas de Base de Datos

package dbiter

import (
    "database/sql"
    "iter"
)

type RowResult[T any] struct {
    Value T
    Err   error
}

func QueryRows[T any](db *sql.DB, query string, scan func(*sql.Rows) (T, error)) iter.Seq[RowResult[T]] {
    return func(yield func(RowResult[T]) bool) {
        rows, err := db.Query(query)
        if err != nil {
            yield(RowResult[T]{Err: err})
            return
        }
        defer rows.Close()

        for rows.Next() {
            v, err := scan(rows)
            if err != nil {
                yield(RowResult[T]{Err: err})
                return
            }
            if !yield(RowResult[T]{Value: v}) {
                return
            }
        }
        if err := rows.Err(); err != nil {
            yield(RowResult[T]{Err: err})
        }
    }
}

type Product struct {
    ID    int
    Name  string
    Price float64
}

func main() {
    db, _ := sql.Open("postgres", "dsn")

    products := QueryRows(db,
        "SELECT id, name, price FROM products",
        func(rows *sql.Rows) (Product, error) {
            var p Product
            err := rows.Scan(&p.ID, &p.Name, &p.Price)
            return p, err
        },
    )

    for r := range products {
        if r.Err != nil {
            log.Printf("Error de iteración: %v", r.Err)
            break
        }
        fmt.Printf("%s: $%.2f\n", r.Value.Name, r.Value.Price)
    }
}

Pipeline de Propagación de Errores

func SafeMap[V any, U any](seq iter.Seq[RowResult[V]], fn func(V) (U, error)) iter.Seq[RowResult[U]] {
    return func(yield func(RowResult[U]) bool) {
        for r := range seq {
            if r.Err != nil {
                if !yield(RowResult[U]{Err: r.Err}) {
                    return
                }
                return
            }
            u, err := fn(r.Value)
            if err != nil {
                if !yield(RowResult[U]{Err: err}) {
                    return
                }
                return
            }
            if !yield(RowResult[U]{Value: u}) {
                return
            }
        }
    }
}

func SafeFilter[V any](seq iter.Seq[RowResult[V]], pred func(V) (bool, error)) iter.Seq[RowResult[V]] {
    return func(yield func(RowResult[V]) bool) {
        for r := range seq {
            if r.Err != nil {
                if !yield(r) {
                    return
                }
                return
            }
            ok, err := pred(r.Value)
            if err != nil {
                if !yield(RowResult[V]{Err: err}) {
                    return
                }
                return
            }
            if ok {
                if !yield(r) {
                    return
                }
            }
        }
    }
}

Patrón 7: Diseño de Biblioteca de Iteradores de Grado de Producción

Principios de Diseño

┌─────────────────────────────────────────────────────┐
│  Principios de Biblioteca de Iteradores de Producción│
├─────────────────────────────────────────────────────┤
│  1. Cero asignación: sin slices intermedios          │
│  2. Componible: todas las ops retornan iter.Seq      │
│  3. Terminable: liberar con yield=false              │
│  4. Observable: propagación de errores y métricas    │
│  5. Testeable: funciones puras, sin efectos secundarios│
└─────────────────────────────────────────────────────┘

Toolkit Completo de Iteradores

package itool

import "iter"

type Seq[V any] = iter.Seq[V]

type Seq2[K any, V any] = iter.Seq2[K, V]

func FromSlice[V any](s []V) Seq[V] {
    return func(yield func(V) bool) {
        for _, v := range s {
            if !yield(v) {
                return
            }
        }
    }
}

func FromMap[K comparable, V any](m map[K]V) Seq2[K, V] {
    return func(yield func(K, V) bool) {
        for k, v := range m {
            if !yield(k, v) {
                return
            }
        }
    }
}

func FromChannel[V any](ch <-chan V) Seq[V] {
    return func(yield func(V) bool) {
        for v := range ch {
            if !yield(v) {
                return
            }
        }
    }
}

func Generate[V any](fn func() (V, bool)) Seq[V] {
    return func(yield func(V) bool) {
        for {
            v, ok := fn()
            if !ok || !yield(v) {
                return
            }
        }
    }
}

func Concat[V any](seqs ...Seq[V]) Seq[V] {
    return func(yield func(V) bool) {
        for _, seq := range seqs {
            for v := range seq {
                if !yield(v) {
                    return
                }
            }
        }
    }
}

func Distinct[V comparable](seq Seq[V]) Seq[V] {
    return func(yield func(V) bool) {
        seen := make(map[V]bool)
        for v := range seq {
            if !seen[v] {
                seen[v] = true
                if !yield(v) {
                    return
                }
            }
        }
    }
}

func Reverse[V any](seq Seq[V]) Seq[V] {
    return func(yield func(V) bool) {
        var items []V
        for v := range seq {
            items = append(items, v)
        }
        for i := len(items) - 1; i >= 0; i-- {
            if !yield(items[i]) {
                return
            }
        }
    }
}

func Skip[V any](seq Seq[V], n int) Seq[V] {
    return func(yield func(V) bool) {
        i := 0
        for v := range seq {
            if i >= n {
                if !yield(v) {
                    return
                }
            }
            i++
        }
    }
}

func TakeWhile[V any](seq Seq[V], pred func(V) bool) Seq[V] {
    return func(yield func(V) bool) {
        for v := range seq {
            if !pred(v) {
                return
            }
            if !yield(v) {
                return
            }
        }
    }
}

func SkipWhile[V any](seq Seq[V], pred func(V) bool) Seq[V] {
    return func(yield func(V) bool) {
        skipping := true
        for v := range seq {
            if skipping {
                if pred(v) {
                    continue
                }
                skipping = false
            }
            if !yield(v) {
                return
            }
        }
    }
}

func Count[V any](seq Seq[V]) int {
    n := 0
    for range seq {
        n++
    }
    return n
}

func Any[V any](seq Seq[V], pred func(V) bool) bool {
    for v := range seq {
        if pred(v) {
            return true
        }
    }
    return false
}

func All[V any](seq Seq[V], pred func(V) bool) bool {
    for v := range seq {
        if !pred(v) {
            return false
        }
    }
    return true
}

func ForEach[V any](seq Seq[V], fn func(V)) {
    for v := range seq {
        fn(v)
    }
}

func ToSlice[V any](seq Seq[V]) []V {
    var result []V
    for v := range seq {
        result = append(result, v)
    }
    return result
}

func ToMap[K comparable, V any](seq Seq2[K, V]) map[K]V {
    result := make(map[K]V)
    for k, v := range seq {
        result[k] = v
    }
    return result
}

func GroupBy[K comparable, V any](seq Seq2[K, V]) map[K][]V {
    result := make(map[K][]V)
    for k, v := range seq {
        result[k] = append(result[k], v)
    }
    return result
}

Ejemplos de Uso

func main() {
    nums := FromSlice([]int{1, 2, 3, 4, 5, 4, 3, 2, 1})

    result := ToSlice(
        Distinct(
            Filter(
                Map(nums, func(n int) int { return n * 2 }),
                func(n int) bool { return n > 4 },
            ),
        ),
    )

    fmt.Println(result)

    evenCount := Count(Filter(FromSlice([]int{1, 2, 3, 4, 5, 6}), func(n int) bool {
        return n%2 == 0
    }))
    fmt.Println("Cantidad de pares:", evenCount)

    hasNegative := Any(FromSlice([]int{1, 2, 3}), func(n int) bool {
        return n < 0
    })
    fmt.Println("Tiene negativos:", hasNegative)
}

5 Errores Comunes y Soluciones

Error 1: Capturar Variables de Bucle en Iteradores

func BuggyFactory() []iter.Seq[int] {
    var seqs []iter.Seq[int]
    for i := 0; i < 3; i++ {
        seqs = append(seqs, func(yield func(int) bool) {
            yield(i)
        })
    }
    return seqs
}

Todos los iteradores devuelven 3. i es capturado por closure, el valor es 3 cuando el bucle termina.

Solución:

func FixedFactory() []iter.Seq[int] {
    var seqs []iter.Seq[int]
    for i := 0; i < 3; i++ {
        i := i
        seqs = append(seqs, func(yield func(int) bool) {
            yield(i)
        })
    }
    return seqs
}

Error 2: Olvidar Llamar stop Causa Fugas de Recursos

next, stop := iter.Pull(FileLines("big.log"))
v, ok := next()
fmt.Println(v)

El archivo nunca se cierra.

Solución:

next, stop := iter.Pull(FileLines("big.log"))
defer stop()
v, ok := next()
fmt.Println(v)

Error 3: Los Iteradores No Son Reentrantes

seq := Fibonacci()
for v := range Take(seq, 5) {
    fmt.Println(v)
}
for v := range Take(seq, 5) {
    fmt.Println(v)
}

El segundo range no produce nada. Los iteradores son de uso único.

Solución:

fibFactory := func() iter.Seq[int] { return Fibonacci() }

for v := range Take(fibFactory(), 5) {
    fmt.Println(v)
}
for v := range Take(fibFactory(), 5) {
    fmt.Println(v)
}

Error 4: Panic en Iteradores

func RiskySeq() iter.Seq[int] {
    return func(yield func(int) bool) {
        panic("oops")
    }
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recuperado:", r)
        }
    }()
    for v := range RiskySeq() {
        fmt.Println(v)
    }
}

En Go 1.24, los panics desde range over func pueden ser recuperados externamente. Pero no dependas de este comportamiento — los iteradores deberían manejar sus propios errores.

Error 5: Range Concurrente Sobre el Mismo Iterador

seq := FromSlice([]int{1, 2, 3, 4, 5})

var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        for v := range seq {
            fmt.Println(v)
        }
    }()
}
wg.Wait()

iter.Seq no es seguro para concurrencia. Múltiples goroutines iterando simultáneamente causa data races.

Solución: Usa el patrón Fan-out, o crea iteradores independientes para cada goroutine.

10 Soluciones a Errores Comunes

Error	Causa	Solución
`cannot range over seq (variable of type func(yield func(int) bool))`	La firma de la función no coincide con iter.Seq	Asegúrate de que la firma sea `func(yield func(V) bool)`
`cannot use function as type iter.Seq[int]`	El tipo del parámetro yield no coincide	Verifica que el tipo del parámetro yield coincida con el parámetro de tipo Seq
`iter.Pull: iterator did not call stop`	No se llamó a stop del iterador Pull	Siempre usa `defer stop()`
`panic: range over func: yield called after return`	yield llamado después del retorno del iterador	Verifica si las goroutines llaman yield después del retorno
`deadlock`	inputCh/outputCh de Fan-out no cerrados	Asegúrate de que todas las goroutines salgan antes de cerrar los canales
`data race`	Múltiples goroutines iterando el mismo Seq	Cada goroutine usa un iterador independiente
`out of memory`	Iterador infinito sin Take	Siempre usa Take/Skip con secuencias infinitas
`goroutine leak`	Goroutines en el iterador nunca salen	Usa context o canal done para control de salida
`unexpected EOF during iteration`	Archivo modificado durante iteración de archivo	Usa file locks o snapshots
`yield returns false but iteration continues`	Valor de retorno de yield no verificado	Verifica el retorno de yield después de cada llamada, retorna en false

Consejos Avanzados de Optimización

Consejo 1: Pre-asignación para Reducir la Presión del GC

func ToSlicePrealloc[V any](seq Seq[V], hint int) []V {
    result := make([]V, 0, hint)
    for v := range seq {
        result = append(result, v)
    }
    return result[:len(result)]
}

Cuando conoces el conteo aproximado, pre-asigna para evitar múltiples redimensionamientos.

Consejo 2: Iterador por Lotes para Reducir Llamadas al Sistema

func Batched[V any](seq Seq[V], batchSize int) Seq[[]V] {
    return func(yield func([]V) bool) {
        batch := make([]V, 0, batchSize)
        for v := range seq {
            batch = append(batch, v)
            if len(batch) == batchSize {
                if !yield(batch) {
                    return
                }
                batch = make([]V, 0, batchSize)
            }
        }
        if len(batch) > 0 {
            yield(batch)
        }
    }
}

Para inserciones por lotes en base de datos, confirma cada 100 filas para reducir viajes de ida y vuelta de red.

Consejo 3: Iterador + Context para Control de Timeout

func WithContext[V any](ctx context.Context, seq Seq[V]) Seq[V] {
    return func(yield func(V) bool) {
        for v := range seq {
            select {
            case <-ctx.Done():
                return
            default:
                if !yield(v) {
                    return
                }
            }
        }
    }
}

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

for v := range WithContext(ctx, SlowIterator()) {
    fmt.Println(v)
}

Análisis Comparativo: Iteradores vs Canales vs Slices

Dimensión	Iterador (iter.Seq)	Canal (chan)	Slice ([]T)
Uso de memoria	O(1)	O(n) buffer	O(n)
Evaluación diferida	Sí	No	No
Secuencias infinitas	Sí	No	No
Seguro para concurrencia	No	Sí	No
Componibilidad	Excelente (cadena de funciones)	Media (necesita goroutine)	Pobre (slices intermedios)
Manejo de errores	Requiere envoltorio	Soporte nativo	Retorno directo de error
Reentrante	No	No	Sí
Rendimiento	Cero asignación	Sobrecarga de lock	Sobrecarga de copia
Caso de uso	Pipelines de datos, eval. diferida	Comunicación concurrente	Conjuntos pequeños, acceso aleatorio
Versión de Go	1.24+	1.0+	1.0+
Dificultad de depuración	Media	Alta	Baja

Árbol de Decisión

Necesitas evaluación diferida o secuencias infinitas?
├── Sí → Iterador
└── No
    ├── Necesitas comunicación concurrente?
    │   └── Sí → Canal
    └── No
        ├── Datos pequeños + acceso aleatorio?
        │   └── Sí → Slice
        └── No → Iterador

Herramientas en Línea Recomendadas

Formateador JSON — Formatea salida JSON de iteradores
Formateador de Código — Formatea código de iteradores Go
Formateador SQL — Formatea consultas SQL en iteradores

Referencias Externas

Documentación del Paquete iter de Go — Referencia del paquete iter de la biblioteca estándar de Go
Propuesta de Range Over Func en Go — Documento de diseño de range over func

Resumen

Los patrones de iterador de Go 1.24 otorgan a Go capacidades nativas, sin asignación de memoria y componibles de pipeline de datos. Los 7 patrones core cubren todo el espectro desde recorrido básico hasta diseño de biblioteca de grado de producción:

Iterador básico range over func — El punto de partida, yield controla el flujo

Conversión de iteradores Push/Pull — iter.Pull permite control manual

Composición de pipeline de datos — Encadenamiento Map/Filter/Reduce con cero asignación intermedia

Evaluación diferida y secuencias infinitas — Calcula bajo demanda, procesa flujos infinitos

Iteradores concurrentes y Fan-out — Consumo paralelo con múltiples goroutines

Manejo de errores en iteradores — Patrón RowResult para propagación elegante de errores

Diseño de biblioteca de iteradores de grado de producción — Cero asignación, componible, terminable

Los iteradores no son un reemplazo de los canales o los slices. Son un nuevo miembro del toolkit de procesamiento de datos de Go — cuando necesitas evaluación diferida y composición de pipeline sin asignación de memoria, los iteradores son la mejor opción.

Lectura Relacionada: