Go 1.24イテレータパターン：range over funcからデータパイプラインまで7つのプロダクションパターン
编程语言
forループが関数と出会う時：Goイテレータのパラダイムシフト
先週、データ処理サービスをリファクタリングしました。3層のネストされたforループで10万件のレコードを処理すると、メモリが2GBに急増——各層で中間結果をスライスに保存してから次の層に渡すからです。イテレータパイプラインに変更後、メモリは15MBに低下し、処理速度は逆に30%速くなりました。重要な転換点：**「集めてから処理」ではなく、「反復しながら処理」**へ。
Go 1.24はrange over func構文とiterパッケージを正式に安定化させ、Goにネイティブでゼロアロケーション、コンポーザブルなイテレータをもたらしました。これはシンタックスシュガーではなく、データ処理パラダイムの根本的な転換です。本記事では7つのプロダクションレベルのGoイテレータパターンを解説し、効率的でエレガント、コンポーザブルなデータパイプラインの構築を支援します。
主要ポイント
- range over funcはイテレータのコア構文：Go 1.24で関数が直接range可能に
- Push/Pullイテレータ変換：イテレータの2つの方向を理解し、
iter.Pull変換をマスター - データパイプライン合成：Map/Filter/Reduceのチェーン合成、ゼロ中間アロケーション
- 遅延評価と無限シーケンス：オンデマンド計算、無限データストリームの処理
- 並行イテレータとFan-out：複数goroutineによる並列消費
- イテレータエラー処理：反復中のエラーを優雅に処理
- プロダクションレベルのイテレータライブラリ設計：再利用可能なイテレータツールキットの構築
目次
- Goイテレータコア概念クイックリファレンス
- Pattern 1：range over func基本イテレータ
- Pattern 2：Push/Pullイテレータ変換
- Pattern 3：データパイプライン合成（Map/Filter/Reduce）
- Pattern 4：遅延評価と無限シーケンス
- Pattern 5：並行イテレータとFan-out
- Pattern 6：イテレータエラー処理
- Pattern 7：プロダクションレベルのイテレータライブラリ設計
- 5つのよくある落とし穴と解決策
- 10のよくあるエラートラブルシューティング
- 高度な最適化テクニック
- 比較分析：イテレータ vs チャネル vs スライス
- オンラインツール推奨
- まとめ
Goイテレータコア概念クイックリファレンス
| 概念 | シグネチャ | 用途 | 例 |
|---|---|---|---|
| イテレータ関数 | func(yield func(V) bool) |
単値イテレータ | func(yield func(int) bool) |
| キー値イテレータ | func(yield func(K, V) bool) |
キー値ペア反復 | func(yield func(int, string) bool) |
| Pullイテレータ | func() (V, bool) |
オンデマンド取得 | next, stop := iter.Pull(seq) |
| iter.Pull | func(Seq[V]) (func() (V, bool), func()) |
Push→Pull変換 | コンシューマ駆動トラバーサル |
| iter.Stop | 組み込みstop関数 | 早期終了 | stop() リソース解放 |
| yield戻り値 | bool |
反復継続/停止の制御 | yield(v) がfalseを返すと停止 |
| 遅延評価 | 遅延計算 | オンデマンド値生成 | 無限シーケンス、ファイル行 |
| パイプライン合成 | 関数チェーン呼び出し | ゼロ中間アロケーション | Filter(Map(Seq, fn), pred) |
Pattern 1：range over func基本イテレータ
問題：従来の反復のメモリトラップ
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()
}
100万ユーザー？100万件のUser構造体がすべてメモリにロードされます。最初の10件だけ必要？残念、まず全件ロードが必要です。
解決策：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++
}
}
}
使用方法：
for i, user := range AllUsers(db) {
fmt.Printf("%d: %s\n", i, user.Name)
if i >= 9 {
break
}
}
break時、yieldがfalseを返し、イテレータ関数は即座にreturn——10件だけクエリされ、データベース接続は正常にクローズされます。
イテレータ実行フロー
┌─────────────┐ yield(v) ┌──────────────┐
│ イテレータ │ ──────────────→ │ rangeループ │
│ (producer) │ │ (consumer) │
│ │ ←────────────── │ │
│ │ yield戻り値bool │ │
└─────────────┘ └──────────────┘
│ │
│ yieldがfalseを返す → return │
│ (早期終了) │
└──────────────────────────────────┘
単値イテレータ vs キー値イテレータ
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)
}
Pattern 2：Push/Pullイテレータ変換
PushイテレータとPullイテレータの違い
Pushイテレータ (iter.Seq) Pullイテレータ (func() (V, bool))
┌──────────────────┐ ┌──────────────────┐
│ プロデューサが │ │ コンシューマが │
│ プッシュする │ │ プルする │
│ yield(v) → 消費者│ │ next() → 生産者 │
│ │ │ │
│ 適合：range反復 │ │ 適合：手動制御 │
│ 適合：パイプライン│ │ 適合：先読み │
│ 適合：遅延評価 │ │ 適合：相互運用 │
└──────────────────┘ └──────────────────┘
│ │
│ iter.Pull() 変換 │
└──────────────────────────────────┘
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("早期終了")
break
}
}
}
Pullイテレータの実践的応用：Peekと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))
重要：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("最初の行:", v)
}
}
defer stop()は1つの値しか消費しなくても、ファイルが正しくクローズされることを保証します。
Pattern 3：データパイプライン合成（Map/Filter/Reduce）
問題：ネストされたループと中間スライス
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回のトラバーサル、2つの中間スライス。データ量が大きい場合、メモリとGCの圧力は重大です。
解決策：イテレータパイプライン
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
}
パイプライン合成の使用
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("合計: %.2f\n", total)
}
ゼロ中間アロケーション：Filter、Map、Reduceがチェーンされ、各要素は1回だけ処理されます。
パイプライン実行フロー
OrdersFromDB → Filter(active) → Map(×1.1) → Reduce(+) → total
│ │ │ │
│ Order{1, │ Status== │ Amount*1.1 │ acc+v
│ "active", │ "active"? │ │
│ 100.0} │ │ │
│ ──────→ │ ✓ パス │ │
│ │ ──────→ │ 110.0 │
│ │ │ ──────→ │ 110.0
│
│ Order{2, │ Status!= │ │
│ "closed", │ "active" │ │
│ 200.0} │ ✗ フィルタ │ │
│ ──────→ │ スキップ │ │
さらなるパイプラインオペレータ
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)
}
}
}
Pattern 4：遅延評価と無限シーケンス
問題：全結果の事前計算の無駄
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
}
最初の10個のフィボナッチ数が必要？nを指定する必要があります。いくつ必要かわからない？「十分大きい」値を事前計算するしかありません。
解決策：無限イテレータ + 遅延評価
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
}
}
}
}
}
遅延シーケンスの使用
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()
}
遅延ファイル処理
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)
}
}
10GBのログファイル？最初の100行のERRORだけ読み取り、メモリ使用量はほぼゼロです。
Pattern 5：並行イテレータとFan-out
問題：シングルスレッドイテレータのパフォーマンスボトルネック
func ProcessImages(images iter.Seq[Image]) []Result {
var results []Result
for img := range images {
r := expensiveTransform(img)
results = append(results, r)
}
return results
}
1000枚の画像、各100ms、合計100秒。CPU利用率はわずか12.5%（8コア中1コアのみ使用）。
解決策：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++
}
}
}
}
並行イテレータの使用
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("処理完了: %s\n", r.Path)
}
}
並行イテレータアーキテクチャ
┌──────────┐
│ Seq[V] │
│ (入力源) │
└────┬─────┘
│
┌─────▼─────┐
│ inputCh │
└─────┬─────┘
│
┌───────────┼───────────┐
│ │ │
┌────▼───┐ ┌───▼────┐ ┌──▼─────┐
│Worker 1│ │Worker 2│ │Worker N│
│ fn(v) │ │ fn(v) │ │ fn(v) │
└────┬───┘ └───┬────┘ └──┬─────┘
│ │ │
└───────────┼──────────┘
│
┌─────▼─────┐
│ outputCh │
└─────┬─────┘
│
┌─────▼─────┐
│ yield(U) │
│ (消費者) │
└───────────┘
Pattern 6：イテレータエラー処理
問題：イテレータでエラーが飲み込まれる
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
}
}
}
}
decoder.Decodeが失敗した時、エラー情報は完全に失われます。呼び出し側は正常終了かエラーかを判別できません。
解決策：エラー伝播付きイテレータ
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
}
}
}
}
実践的応用：データベース行イテレータ
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("反復エラー: %v", r.Err)
break
}
fmt.Printf("%s: $%.2f\n", r.Value.Name, r.Value.Price)
}
}
エラー伝播パイプライン
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
}
}
}
}
}
Pattern 7：プロダクションレベルのイテレータライブラリ設計
設計原則
┌─────────────────────────────────────────────┐
│ プロダクションレベルイテレータライブラリ │
│ 設計原則 │
├─────────────────────────────────────────────┤
│ 1. ゼロアロケーション：中間スライスなし │
│ 2. コンポーザブル：全操作がiter.Seqを返す │
│ 3. 終了可能：yield=falseで即座にリソース解放 │
│ 4. 観測可能：エラー伝播とメトリクス収集 │
│ 5. テスト可能：純粋関数、副作用なし │
└─────────────────────────────────────────────┘
完全なイテレータツールキット
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
}
使用例
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("偶数の数:", evenCount)
hasNegative := Any(FromSlice([]int{1, 2, 3}), func(n int) bool {
return n < 0
})
fmt.Println("負数あり:", hasNegative)
}
5つのよくある落とし穴と解決策
落とし穴1：イテレータでループ変数をキャプチャ
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
}
すべてのイテレータが3を返します。iがクロージャにキャプチャされ、ループ終了時の値は3です。
修正：
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
}
落とし穴2：stopの呼び出し忘れによるリソースリーク
next, stop := iter.Pull(FileLines("big.log"))
v, ok := next()
fmt.Println(v)
ファイルが永遠にクローズされません。
修正：
next, stop := iter.Pull(FileLines("big.log"))
defer stop()
v, ok := next()
fmt.Println(v)
落とし穴3：イテレータは再入可能ではない
seq := Fibonacci()
for v := range Take(seq, 5) {
fmt.Println(v)
}
for v := range Take(seq, 5) {
fmt.Println(v)
}
2回目のrangeは何も出力しません。イテレータは使い捨てです。
修正：
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)
}
落とし穴4：イテレータ内のpanic
func RiskySeq() iter.Seq[int] {
return func(yield func(int) bool) {
panic("oops")
}
}
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("recovered:", r)
}
}()
for v := range RiskySeq() {
fmt.Println(v)
}
}
Go 1.24では、range over funcのpanicは外部でrecoverできます。しかしこの動作に依存しないでください——イテレータは自身でエラーを処理すべきです。
落とし穴5：同じイテレータを並行range
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は並行安全ではありません。複数のgoroutineが同時にrangeするとデータ競合が発生します。
修正：Fan-outパターンを使用するか、各goroutineに独立したイテレータを作成してください。
10のよくあるエラートラブルシューティング
| エラー | 原因 | 解決策 |
|---|---|---|
cannot range over seq (variable of type func(yield func(int) bool)) |
関数シグネチャがiter.Seqに不一致 | シグネチャをfunc(yield func(V) bool)に |
cannot use function as type iter.Seq[int] |
yield関数パラメータ型の不一致 | yieldパラメータ型がSeq型パラメータと一致するか確認 |
iter.Pull: iterator did not call stop |
Pullイテレータのstopが未呼び出し | 常にdefer stop()を使用 |
panic: range over func: yield called after return |
return後にyieldが呼び出された | goroutineで遅延yield呼び出しがないか確認 |
deadlock |
Fan-outのinputCh/outputChが未クローズ | 全goroutine終了後にchannelをclose |
data race |
複数goroutineが同じSeqをrange | 各goroutineで独立したイテレータを使用 |
out of memory |
無限イテレータにTake未使用 | 無限シーケンスには常にTake/Skipを使用 |
goroutine leak |
イテレータ内のgoroutineが終了しない | contextやdone channelで終了制御 |
unexpected EOF during iteration |
ファイル反復中にファイルが変更された | ファイルロックやスナップショットを使用 |
yield returns false but iteration continues |
yield戻り値が未チェック | 毎回yield後に戻り値をチェック、falseならreturn |
高度な最適化テクニック
テクニック1：事前割り当てで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)]
}
おおよその数がわかっている場合、事前割り当てで複数回のリサイズを回避します。
テクニック2：バッチイテレータでシステムコールを削減
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)
}
}
}
データベースバッチインサート時、100件ごとにコミットしてネットワークラウンドトリップを削減。
テクニック3：イテレータ + contextでタイムアウト制御
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)
}
比較分析：イテレータ vs チャネル vs スライス
| 次元 | イテレータ (iter.Seq) | チャネル (chan) | スライス ([]T) |
|---|---|---|---|
| メモリ使用量 | O(1) | O(n) バッファ | O(n) |
| 遅延評価 | 対応 | 非対応 | 非対応 |
| 無限シーケンス | 対応 | 非対応 | 非対応 |
| 並行安全性 | なし | あり | なし |
| 合成性 | 優秀（関数チェーン） | 中程度（goroutine必要） | 低い（中間スライス） |
| エラー処理 | ラッピング必要 | ネイティブ対応 | 直接error返却 |
| 再入可能性 | なし | なし | あり |
| パフォーマンス | ゼロアロケーション | ロックオーバーヘッド | コピーオーバーヘッド |
| ユースケース | データパイプライン、遅延評価 | 並行通信 | 小データセット、ランダムアクセス |
| Goバージョン | 1.24+ | 1.0+ | 1.0+ |
| デバッグ難易度 | 中程度 | 高い | 低い |
決定ツリー
遅延評価や無限シーケンスが必要？
├── はい → イテレータ
└── いいえ
├── 並行通信が必要？
│ └── はい → チャネル
└── いいえ
├── データが小さくランダムアクセスが必要？
│ └── はい → スライス
└── いいえ → イテレータ
オンラインツール推奨
- JSONフォーマッター — イテレータ出力のJSONデータをフォーマット
- コードフォーマッター — Goイテレータコードをフォーマット
- SQLフォーマッター — イテレータ内のSQLクエリをフォーマット
外部リファレンス
- Go iterパッケージ公式ドキュメント — Go標準ライブラリiterパッケージリファレンス
- Go Range Over Funcプロポーザル — range over func設計ドキュメント
まとめ
Go 1.24イテレータパターンは、Goにネイティブでゼロアロケーション、コンポーザブルなデータパイプライン能力をもたらします。7つのコアパターンは基本的なトラバーサルからプロダクションレベルのライブラリ設計まで完全なチェーンをカバーします：
- range over func基本イテレータ — すべての反復の起点、yieldがフローを制御
- Push/Pullイテレータ変換 — iter.Pullで手動制御を可能に
- データパイプライン合成 — Map/Filter/Reduceチェーン、ゼロ中間アロケーション
- 遅延評価と無限シーケンス — オンデマンド計算、無限ストリームの処理
- 並行イテレータとFan-out — 複数goroutineによる並列消費
- イテレータエラー処理 — RowResultパターンで優雅なエラー伝播
- プロダクションレベルのイテレータライブラリ設計 — ゼロアロケーション、コンポーザブル、終了可能
イテレータはチャネルの代替でもスライスの代替でもありません。Goのデータ処理ツールボックスの新しいメンバーです——遅延評価とゼロアロケーションパイプライン合成が必要な時、イテレータが最良の選択です。
関連記事：
ブラウザローカルツールを無料で試す →
#Go#迭代器#Iterator#range over func#数据管道#Go 1.24#2026#编程语言