---
title: "Go 1.26 iterators turned the simplest language into functional spaghetti"
url: https://daily.dev/posts/go-1-26-iterators-turned-the-simplest-language-into-functional-spaghetti-wlsdlr14u
source_url: https://dev.to/adioof/go-126-iterators-turned-the-simplest-language-into-functional-spaghetti-5c4h
type: article
source: "Awesome Go"
published: 2026-08-20T20:15:43.639Z
updated: 2026-08-24T07:10:10.656Z
tags: ["architecture", "golang", "language-design"]
reading_time: 4
upvotes: 5
comments: 0
language: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Go 1.26 iterators turned the simplest language into functional spaghetti

**[Awesome Go](https://daily.dev/sources/awego)** · 4 min read · 5 upvotes · 0 comments

## Summary

An opinion piece argues that Go's range-over-func iterators, introduced in Go 1.23 (August 2024) and expanded in the reflect package with Go 1.26 (February 2026), betray Go's original design philosophy of simplicity. The author cites benchmarks from Val Deleplace and Rost Glukhov showing custom iterators are typically slower than direct loops, and points to community division over whether the feature is elegant or a mistake. A top comment pushes back, noting the writer's own 63k-line Go 1.26 codebase uses zero iter.Seq instances and arguing the addition is optional rather than forced.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://dev.to/adioof/go-126-iterators-turned-the-simplest-language-into-functional-spaghetti-5c4h>

## Questions this post answers

### What did Go 1.23 introduce for iterators and what is range over func?

Go 1.23, released in August 2024, introduced range-over-func iterators using the iter.Seq and iter.Seq2 types, letting you range directly over a function. This requires understanding push and pull iterators, yield callbacks, and boolean returns for early termination, concepts not previously needed to write a basic Go for loop.

_Track how new Go releases reshape everyday loop code by following golang updates on daily.dev._

### Are Go iterators slower than a regular for loop over a slice or map?

Yes, ranging over an iterator is measurably slower than ranging directly over a slice or map. Google Developer Expert Val Deleplace benchmarked this in September 2024, and a January 2025 study by Rost Glukhov found custom iterators rarely execute faster than the classical approach, concluding the choice mostly comes down to aesthetic preference rather than performance.

_Developers weighing iterator abstractions against raw loops can compare tradeoffs like this on daily.dev._

### What changed in the Go 1.26 reflect package related to iterators?

Go 1.26, released in February 2026, revamped the reflect package to add iterator-based methods including Type.Fields, Type.Methods, Value.Fields, and Value.Methods, sitting alongside the older NumField and Field(i) loop-based approach rather than replacing it. By August 2026 iterator usage had spread widely across libraries and code reviews in the Go ecosystem.

_Keep up with reflect package and standard library shifts in Go by tracking golang releases on daily.dev._

---

Tags: [#architecture](https://daily.dev/tags/architecture), [#golang](https://daily.dev/tags/golang), [#language-design](https://daily.dev/tags/language-design)

[View this post on daily.dev](https://daily.dev/posts/go-1-26-iterators-turned-the-simplest-language-into-functional-spaghetti-wlsdlr14u)