Saturday, May 18, 2024
HomeGolangVary-Over Capabilities in Go

Vary-Over Capabilities in Go


In my earlier publish, I mentioned the present state of looping in Go. On this publish, we’re going to look right into a future function for the Go programming language known as range-over operate experiment. Go lacks an ordinary iterator protocol and that is an try to supply one. We’ll talk about the motivation for including this new function and see some examples on use it.

NOTE: To be able to run the code, you want to set the GOEXPERIMENT setting variable to rangefunc (e.g. export GOEXPERIMENT=rangefunc).

NOTE: If you’re accustomed to Python’s iterators and turbines, this weblog publish will appear acquainted. ☺

Earlier than we dive into the main points of range-over features, let’s check out two frequent iteration patterns: container iterators and inversion of management

Container Iterators

Let’s begin with a fundamental container kind. Right here is an instance of a stack that’s applied utilizing a linked listing.

Itemizing 1: Stack

10 kind node[T any] struct {
11     worth T
12     subsequent  *node[T]
13 }
15 kind Stack[T any] struct {
16     head *node[T]
17 }
19 func (s *Stack[T]) Push(v T) {
20     s.head = &node[T]{v, s.head}
21 }
23 var ErrEmpty = errors.New("empty stack")
25 func (s *Stack[T]) Pop() (T, error) {
26     if s.head == nil {
27         var v T
28         return v, ErrEmpty
29     }
31     n := s.head
32     s.head = s.head.subsequent
33     return n.worth, nil
34 }

Itemizing 1 exhibits a stack implementation. On traces 10-13, we outline a node kind with a worth and subsequent discipline. Then on traces 15-17, we outline a Stack kind that has a head discipline of kind node. Lastly on traces 19-21, we outline the Push methodology and on traces 25-34, we outline a Pop methodology.

We don’t need the Stack kind to maintain monitor of any iteration location. If now we have multiple iteration going on the similar time, the bookkeeping of the place every particular person iteration is at the moment occurring turns into advanced. To maintain issues easy, we’re going to outline an iterator that’s chargeable for a single iteration at a time.

Itemizing 2: StackIterator

36 func (s *Stack[T]) Gadgets() *StackIterator[T] {
37     return &StackIterator[T]{s.head}
38 }
40 kind StackIterator[T any] struct {
41     node *node[T]
42 }
44 func (s *StackIterator[T]) Subsequent() (T, bool) {
45     if s.node == nil {
46         var v T
47         return v, false
48     }
50     n := s.node
51     s.node = s.node.subsequent
52     return n.worth, true
53 }

Itemizing 2 exhibits the implementation of an iterator for the stack. On traces 36-38, we outline a technique named Gadgets that returns a pointer to a worth of the StackIterator kind. On traces 40-42, we outline the StackIterator kind which holds the present node being iterated over. Lastly on traces 44-53, we outline the Subsequent methodology that returns the following worth within the stack from the present iteration place.

Itemizing 3: Utilizing the Iterator

128     it := s.Gadgets()
129     for v, okay := it.Subsequent(); okay; v, okay = it.Subsequent() {
130         fmt.Println(v)
131     }

Itemizing 3 exhibits use the iterator. On line 128, we create an iterator utilizing the Merchandise methodology from the Stack kind. Then on traces 129-131, we iterate over the objects within the stack utilizing the Subsequent methodology from the StackIterator kind. When the Subsequent methodology returns false for the second worth, it means there aren’t any extra objects left to iterate over.

Now that you simply perceive how separating iterators from containers simplifies iteration help, we are able to have a look at how inversion of management helps us write a single iterator implementation.

Inversion of Management

Inversion of management is an outdated and established thought. It lets the framework (in our case, the “for” loop) do the circulation so the consumer solely wants to provide the enterprise logic.

Say we need to print all of the objects within the stack, we are able to write the next code:

Itemizing 4: PrintItems

55 func (s *Stack[T]) PrintItems() {
56     for n := s.head; n != nil; n = n.subsequent {
57         fmt.Println(n.worth)
58     }
59 }

Itemizing 4 exhibits the PrintItems methodology. On line 56, we use a for loop to iterate over the nodes after which on line 54, we print the worth of every node that exists.

Now, what if as a substitute of printing values we need to save the values to a file, or possibly ship them as a response in an HTTP request handler?

We’re not going to jot down a number of implementations for every situation I simply talked about. As a substitute we are going to write one implementation named Do that performs the for loop and executes a second operate named yield which is handed in by the consumer to supply the enterprise logic.

Itemizing 5: Do Technique

61 func (s *Stack[T]) Do(yield func(v T)) {
62     for n := s.head; n != nil; n = n.subsequent {
63         yield(n.worth)
64     }
65 }

Itemizing 5 exhibits the Do methodology. On line 61, we outline the Do methodology that accepts a yield operate that may course of a worth of some kind T. Then on line 62, we iterate over the nodes after which on line 63, we cross the present worth to the yield operate.

Itemizing 6: Utilizing The Do Technique

134     s.Do(func(n int) {
135         fmt.Println(n)
136     })

Itemizing 6 exhibits use the Do methodology. On line 134, we name Do with an nameless operate that accepts a parameter of kind int after which prints the worth. On this case, the worth of some kind T is a worth of kind int.

You may see this Do sample in a number of locations in the usual library. For instance: fs.WalkDir and ring.Do.

What occurs if we need to cease the iteration after the primary 5 values? The present implementation can’t be stopped, but when we modify the yield operate to return a boolean worth, it could point out that the iteration ought to cease. Which brings us to the subject at hand: range-over operate.

Vary-Over Capabilities

To check out range-over features in Go 1.22, you want to set the GOEXPERIMENT setting variable to rangefunc. Then we have to use the brand new customary library package deal named iter that defines two new varieties:

Itemizing 7: iter.Seq and iter.Seq2

kind Seq[V any] func(yield func(V) bool)

kind Seq2[K, V any] func(yield func(Ok, V) bool)

Itemizing 7 exhibits the brand new iter.Seq & iter.Seq2 varieties.

Let’s begin with the iter.Seq kind. It defines a operate that accepts a yield operate as a parameter. The yield operate is outlined to simply accept a worth and return a bool. It’s very very like our Do methodology implementation from above, however now the for assertion straight helps it.

Let’s make modifications to our stack implementation to help this new range-over operate help.

Itemizing 8: Iter

67 func (s *Stack[T]) Iter() func(func(T) bool) {
68     iter := func(yield func(T) bool) {
69         for n := s.head; n != nil; n = n.subsequent {
70             if !yield(n.worth) {
71                 return
72             }
73         }
74     }
76     return iter
77 }

Itemizing 6 exhibits the brand new Iter methodology we’re including to the stack implementation. On line 67, we outline the Iter methodology which returns a operate that matches the iter.Seq kind. On line 68, we outline a literal operate that might be returned from Iter. On line 69, we use a for loop to iterate over the stack nodes. On line 70, we cross the present node worth to the yield operate, and if the yield operate returns false the iteration stops on line 71. Lastly on line 76, we return the iteration operate.

Now let’s use the Iter methodology.

Itemizing 9: Utilizing Iter

139     for v := vary s.Iter() {
140         fmt.Println(v)
141     }

Itemizing 9 exhibits use the brand new Iter methodology. One line 139, we use a daily for-range to print every worth of the stack. On this case, the fmt.Println operate on line 140 represents the yield operate. Since this operate can by no means return a bool, this loop will iterate over the whole stack.

In some circumstances, we’d like each values that may be returned from a for-range loop. For instance, getting the index place and the worth, or within the case of a map each the important thing and the worth. For these circumstances, we are able to use iter.Seq2

Itemizing 10: Iter2

79 func (s *Stack[T]) Iter2() func(func(int, T) bool) {
80     iter := func(yield func(int, T) bool) {
81         for i, n := 0, s.head; n != nil; i, n = i+1, n.subsequent {
82             if !yield(i, n.worth) {
83                 return
84             }
85         }
86     }

Itemizing 10 exhibits the brand new Iter2 methodology we’re including to the stack implementation. On line 79, we outline the Iter2 methodology, which returns a operate that matches the iter.Seq2 kind. On line 80, we outline a literal operate that might be returned from Iter2. On line 81, we use a for loop to iterate over the stack nodes. On line 82, we cross the index and present node worth to the yield operate, and if the yield operate returns false the iteration stops on line 83.

Itemizing 11: Utilizing Iter2

144     for i, v := vary s.Iter2() {
145         fmt.Println(i, v)
146     }

Itemizing 11 exhibits use the brand new Iter2 methodology. One line 144, we use a daily for-range loop to print every worth of the stack. As soon as once more, the fmt.Println operate on line 145 represents the yield operate, however this time we cross each the index and worth to the operate. Since this operate can by no means return a bool, this loop will iterate over the whole stack.

Pulling Values

One other fascinating piece of performance included within the new iter package deal are these pull features.

Itemizing 12: Pull and Pull2

func Pull[V any](seq Seq[V]) (subsequent func() (V, bool), cease func())

func Pull2[K, V any](seq Seq2[K, V]) (subsequent func() (Ok, V, bool), cease func())

These pull features are handed a Seq worth and return a subsequent and cease operate. The subsequent operate is used to drag the following worth from Seq and cease is used to pressure the iteration to cease. The cease operate works by passing a yield operate that returns false on the subsequent iteration.

One instance of why we would want these features is that if we needed to search out the max worth at the moment saved within the stack. Bear in mind, we don’t know the size of the stack (and it might probably be infinite) and we are able to’t index straight into the stack.

Let’s see how we are able to use Pull to jot down our Max performance.

Itemizing 13: Max

91 func Max[T cmp.Ordered](seq iter.Seq[T]) (T, error) {
92     pull, cease := iter.Pull(seq)
93     defer cease()
95     max, okay := pull()
96     if !okay {
97         return m, fmt.Errorf("Max of empty sequence")
98     }
100     for v, okay := pull(); okay; v, okay = pull() {
101         if v > max {
102             max = v
103         }
104     }
106     return max, nil
107 }

Itemizing 13 exhibits the Max operate. On line 91, we outline Max to obtain an iter.Seq worth as a parameter and return the max worth or an error. On line 92, we use iter.Pull to get the pull and cease features. On line 93, we defer the cease operate to sign that we need to cease the iteration as soon as the Max operate returns. On line 95, we use the pull operate to get the primary worth after which on line 96, we verify if there was a worth returned.

On line 100, we use a for loop to iterate over the remainder of the values through the use of the pull operate. On line 101 we verify if the present worth is greater than our present max worth and if that’s the case we replace the max worth on line 102. Lastly, on line 106, we return the maximal worth and nil for error.

Itemizing 14: Utilizing Max

148     m, err := Max(s.Iter())
149     if err != nil {
150         fmt.Println("ERROR:", err)
151     } else {
152         fmt.Println("max:", m)
153     }

Itemizing 14 exhibits use the Max operate. On line 148, we name Max passing the worth returned by the stack’s Iter methodology. On line 149, we verify for an error and print the error on line 150. In any other case on line 152, we print the maximal worth.


The range-over operate experiment tries to offer Go a basic manner to supply customized iterators. Utilizing iter.Seq and iter.Seq2 help you use the acquainted for loop, burdening the implementation of the iter package deal on the library author.

I hope I shed some mild on why now we have this experiment and in addition on use it. You may learn extra about it on the wiki web page.

I’d love to listen to from you in case you have extra concepts on use this experiment. For me, coming from Python, there are lots of examples resembling linear areas, generic filters, generic mapper and extra.

Contact me at



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments