Go语言中迭代函数返回值流的规范模式

for element, err := producer.Produce(); err == nil; element, err = producer.Produce() {
    process(element)
}

package main

import (
    "errors"
    "fmt"
    "io" // 用于模拟io.EOF等标准错误
)

// Producer 模拟一个生产者，每次调用生成一个值，直到达到某个条件返回错误
type Producer struct {
    count int
    limit int
}

// Produce 方法模拟生产一个元素，并在达到限制时返回错误
func (p *Producer) Produce() (string, error) {
    if p.count >= p.limit {
        return "", io.EOF // 模拟文件或数据流结束
    }
    p.count++
    return fmt.Sprintf("element-%d", p.count), nil
}

// process 模拟对生成元素的处理
func process(element string) {
    fmt.Println("Processing:", element)
}

func main() {
    // 创建一个生产者实例，模拟生成5个元素
    producer := &Producer{limit: 5}

    // 使用Go语言的惯用迭代模式
    fmt.Println("--- Using idiomatic Go loop for producer ---")
    for {
        element, err := producer.Produce()
        if err != nil {
            // 在这里处理错误或终止信号
            if errors.Is(err, io.EOF) {
                fmt.Println("Producer finished generating elements (EOF).")
            } else {
                // 处理其他类型的错误
                fmt.Println("Error during production:", err)
            }
            break // 遇到错误或结束信号时跳出循环
        }
        process(element)
    }

    // 另一个常见场景：从io.Reader读取数据
    // 假设我们有一个io.Reader，并希望逐行读取
    // import "bufio"
    // import "strings"
    //
    // fmt.Println("\n--- Another example with io.Reader ---")
    // r := bufio.NewReader(strings.NewReader("line1\nline2\nline3\n"))
    // for {
    //  line, err := r.ReadString('\n')
    //  if err != nil {
    //      if errors.Is(err, io.EOF) {
    //          fmt.Println("End of file reached (io.EOF).")
    //      } else {
    //          fmt.Println("Error reading:", err)
    //      }
    //      break
    //  }
    //  fmt.Print("Read line:", line) // Print而不是Println，因为ReadString会包含换行符
    // }
}