Iterators were added to Go, but they are kind of confusing. Let's figure them out together.
One of the biggest additions to Go in Go 1.23 is the addition of iterators. This has caused controversy because some people believe they complicate Go in non-trivial ways that affect the simplicity and ease of the language. There was a similar view shared when generics were introduced.
The speaker notes they have their own views but leaves it up to viewers to decide. This video discusses what iterators are for and compares them to previous Go versions to see how they might change the way you write Go after release.
Looking at the draft release notes for Go 1.23, there are details of an iter package in the language spec. The iter package provides basic definitions and operations related to iterating over sequences. An iteration is a function that passes successive elements of a sequence to a callback function conventionally named yield. The function stops either when the sequence is finished or when yield returns false indicating to stop the iteration early.
The package defines sequence and sequence2 as shorthand for iterators that pass one or two values. You have yield which takes one thing and returns a bool, or takes a key-value and returns two things.
Using the Go Playground, we can compare a function written in Go 1.22 (latest stable version) and the Go developer branch (including Go 1.23 changes). The example shows a backwards function that iterates through a slice in reverse. In Go 1.22, the implementation requires processing the entire slice - with a million-item slice, you'd have to print all million items or terminate the program.
In the Go 1.23 version, while the backwards function might seem more confusing, it provides more control to the user. You no longer have to wait for the whole function to terminate or print everything. You can print just one element if desired, and you have more control over what to do with the yielded values.
Even though the backwards function implementation is complex, if it were in a different package, the usage is very clean. Complex libraries or packages could use these functions and the iterator proposal to make their APIs simpler. The standard library might incorporate this extensively, and some complicated libraries might use it, but the speaker doesn't see it being used much in day-to-day development.
The Go team added this feature referencing generics as the reason, expecting people to use these for things like traversing trees or linked lists. It could also be useful for working with large files or data streams. There's more to iterators than covered here, and while it's confusing, the speaker suggests not worrying if you don't understand it yet - it likely won't be seen much in the wild and can be learned later when needed.
