Go 1.22 has just been released with a bunch of new features and improvements. In this article, we will explore the new loop semantics and how they can be used to write more expressive and readable code.
1. Loop variable is no longer be shared between iterations
Previously, the loop variable was shared between iterations, from go 1.21 (experimental) and now with go 1.22, the loop variable is created anew with each iteration, effectively eliminating one of the most common foot gun in Go (for both experienced and new gophers). This is no longer needed:
for i := 0; i < 10; i++ {
i := i
go func () {
fmt.Println(i)
}()
}
or this
for i := 0; i < 10; i++ {
go func (i int) {
fmt.Println(i)
}(i)
}
now you can do the more intuitive way:
for i := 0; i < 10; i++ {
go func () {
fmt.Println(i)
}()
}
2. Range over an integer
This feature is straightforward, instead of
for i := 0; i < 10; i++ {
fmt.Println(i)
}
now you can do
for i := range 10 {
fmt.Println(i)
}
and achieve the same result, pretty neat, right?
3. Range over a function
For me, this is one of the most exciting updates to the Go language in a long time. Now Go have a standard way to handle iterator, which is a common pattern in other languages.
With preceding go versions, there wasn’t a standard way to iterate through a data structure, generic is not yet available in the language so, you couldn’t write a simple iterator for different data structures.
bufio.Scanneris an iterator through anio.Reader, where theScanmethod advances to the next value. The value is returned by aBytesmethod. Errors are collected and returned by anErrmethod.database/sql.Rowsiterates through the results of a database query, where theNextmethod advances to the next row and the value is returned by aScanmethod which can return an error.
Let’s have a look at the new loop semantics in action:
please note that despite this feature is available in go 1.22, it’s still experimental and may change in the future, plus you have to build your program using GOEXPERIMENT=rangefunc
// iterate from 0 to 9
In10 := func(yield func(int) bool) {
for i := range 10 {
if !yield(i) {
return
}
}
}
for v := range In10 {
fmt.Println(v) // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
}
In10is a function that takes a functionyieldas an argument.The
yieldfunction takes an integer and returns a boolean, wheneverIn10is used, the loop body will specify theyieldfunction, and theIn10function will call theyieldfunction with the current value of the loop variable.You can easily see that the yield function have a signature that return a bool but the loop body itself does not return anything, this is because inside the loop body,
continueor nothing will be translated toreturn trueandbreakwill be translated toreturn false. Give the user the ability to control the iteration from the loop body.
The compiler will change the for over function to something that looks like this:
Int10(func(i int) bool {
fmt.Println(i)
return true
})
this explanation is somewhat oversimplified, the actual implementation is more complex, you can find more about it here
Besides the one parameter yield function mentioned above, functions that can be ranged over can have zero or two parameters, as long as they have the following signature:
package iter
type Seq0 func(yield func() bool) bool
type Seq[V any] func(yield func(V) bool) bool
type Seq2[K, V any] func(yield func(K, V) bool) bool
More examples:
// iterate over a specific range with start and end value
InRange := func(start, end int) func(yield func(int) bool) {
return func(yield func(int) bool) {
for i := start; i < end; i++ {
if !yield(i) {
return
}
}
}
}
for x := range InRange(5, 10) {
fmt.Println(x) // 5, 6, 7, 8, 9
}
// iterate over words in a string separated by space
Words := func(s string) func(yield func(int, string) bool) {
words := strings.Split(s, " ")
return func(yield func(int, string) bool) {
for i, word := range words {
if !yield(i, word) {
return
}
}
}
}
for i, word := range Words("sun rises in the east") {
fmt.Println(i, word) // 0 sun 1 rises 2 in 3 the 4 east
}
usually, while using some polling based library, you have to write a loop like this:
for {
m, err := reader.ReadMessage(context.Background())
if err != nil {
// handle error
continue
}
// handle message
}
you can leverage the new loop semantics to write a more expressive message poller:
ReaderIterator := func (reader Reader) func (func (Message, error) bool) {
return func (yield func (Message, error) bool) {
for {
m, err := reader.ReadMessage(context.Background())
if !yield(m, err) {
break
}
}
}
}
for message err := range ReaderIterator(reader) {
if err != nil {
// handle error
}
// handle message
}
Pull iterator
All the examples above are push iterators, pushing values to the yield function. But that is not always the case in the real world, sometimes you want to pull values from the iterator.
The Pull function from iter package converse a Seq- standard push iterator to a pull iterator. Calling Pull will start an iteration and returns a pair of functions next and stop, which return the next value from the iterator and stop it, respectively.
InRange := func(start, end int) func(yield func(int) bool) {
return func(yield func(int) bool) {
for i := start; i < end; i++ {
if !yield(i) {
return
}
}
}
}
next, stop := iter.Pull(InRange(5, 7))
defer stop()
for value, more := next(); more; value, more = next() {
fmt.Println(value) // 5, 6
}
The new loop semantics surely is a great addition to the Go language as it opens the door for more idiomatic APIs with range functions.