Go 官方博客
范围函数类型
引言
这是我在 GopherCon 2024 上演讲的博客文章版本。
范围函数类型是 Go 1.23 版本中新增的语言特性。这篇博客文章将解释我们为何添加此新特性、它具体是什么以及如何使用它。
为何？
自 Go 1.18 以来，我们已经能够在 Go 中编写新的泛型容器类型。例如，考虑这个非常简单的 Set 类型，它是一个基于 map 实现的泛型类型。
// Set holds a set of elements.
type Set[E comparable] struct {
m map[E]struct{}
}
// New returns a new [Set].
func New[E comparable]() *Set[E] {
return &Set[E]{m: make(map[E]struct{})}
}
自然地，一个 set 类型需要一种添加元素的方式和一种检查元素是否存在的方式。这里的具体细节并不重要。
// Add adds an element to a set.
func (s *Set[E]) Add(v E) {
s.m[v] = struct{}{}
}
// Contains reports whether an element is in a set.
func (s *Set[E]) Contains(v E) bool {
_, ok := s.m[v]
return ok
}
此外，我们还需要一个函数来返回两个集合的并集。
// Union returns the union of two sets.
func Union[E comparable](s1, s2 *Set[E]) *Set[E] {
r := New[E]()
// Note for/range over internal Set field m.
// We are looping over the maps in s1 and s2.
for v := range s1.m {
r.Add(v)
}
for v := range s2.m {
r.Add(v)
}
return r
}
让我们看看 Union 函数的这个实现。为了计算两个集合的并集，我们需要一种方法来获取每个集合中的所有元素。在这段代码中，我们使用了 for/range 语句遍历 set 类型的未导出字段。这仅当 Union 函数在 set 包中定义时才起作用。
但是有许多原因可能导致有人希望遍历集合中的所有元素。这个 set 包必须为其用户提供某种方式来实现这一点。
那该如何实现呢？
推送集合元素
一种方法是提供一个接受函数的 Set 方法，并对集合中的每个元素调用该函数。我们将此方法称为 Push，因为 Set 将每个值“推”给函数。这里如果函数返回 false，我们就停止调用它。
func (s *Set[E]) Push(f func(E) bool) {
for v := range s.m {
if !f(v) {
return
}
}
}
在 Go 标准库中，我们可以看到这种通用模式用于诸如 sync.Map.Range 方法、flag.Visit 函数以及 filepath.Walk 函数等情况。这是一个通用模式，而非精确模式；恰好，这三个示例的工作方式都不完全相同。
使用 Push 方法打印集合中所有元素的代码如下所示：您调用 Push 并传入一个函数，该函数对元素执行您想要的操作。
func PrintAllElementsPush[E comparable](s *Set[E]) {
s.Push(func(v E) bool {
fmt.Println(v)
return true
})
}
拉取集合元素
遍历 Set 元素的另一种方法是返回一个函数。每次调用该函数时，它会返回 Set 中的一个值，以及一个布尔值，指示该值是否有效。当循环遍历完所有元素时，布尔结果将为 false。在这种情况下，我们还需要一个停止函数，以便在不再需要更多值时调用。
这个实现使用一对通道，一个用于集合中的值，一个用于停止返回值。我们使用一个 goroutine 在通道上发送值。next 函数通过从元素通道读取来返回集合中的一个元素，而 stop 函数通过关闭停止通道来告诉 goroutine 退出。我们需要 stop 函数来确保当不再需要更多值时 goroutine 会退出。
// Pull returns a next function that returns each
// element of s with a bool for whether the value
// is valid. The stop function should be called
// when finished calling the next function.
func (s *Set[E]) Pull() (func() (E, bool), func()) {
ch := make(chan E)
stopCh := make(chan bool)
go func() {
defer close(ch)
for v := range s.m {
select {
case ch <- v:
case <-stopCh:
return
}
}
}()
next := func() (E, bool) {
v, ok := <-ch
return v, ok
}
stop := func() {
close(stopCh)
}
return next, stop
}
标准库中没有任何东西的工作方式完全相同。尽管 我们现在已经看到了两种不同的遍历集合所有元素的方法。不同的 Go 包使用这些方法以及其他一些方法。这意味着当您开始使用一个新的 Go 容器包时，您可能需要学习一种新的循环机制。这也意味着我们无法编写一个可以处理多种不同类型容器的函数，因为容器类型处理循环的方式不同。 我们希望通过开发遍历容器的标准方法来改进 Go 生态系统。 当然，这是许多编程语言中都会出现的问题。 流行的《设计模式》一书，于 1994 年首次出版，将此描述为迭代器模式。您使用迭代器来“提供一种按顺序访问聚合对象的元素而不暴露其底层表示的方法”。这段引文所称的聚合对象正是我所说的容器。聚合对象或容器，就是一个持有其他值的值，就像我们一直在讨论的 与编程中的许多想法一样，迭代器可以追溯到 Barbara Liskov 在 20 世纪 70 年代开发的 CLU 语言。 如今，许多流行语言都以这样或那样的方式提供了迭代器，包括 C++、Java、Javascript、Python 和 Rust 等。 然而，Go 1.23 版本之前没有提供。 众所周知，Go 内置了容器类型：切片（slices）、数组（arrays）和 map。并且它有一种在不暴露底层表示的情况下访问这些值元素的方法：for/range 语句。for/range 语句适用于 Go 的内置容器类型（也适用于字符串、通道，以及 Go 1.22 版本开始支持的 int）。 for/range 语句是一种迭代方式，但它不是如今流行语言中出现的迭代器。尽管如此，如果能够使用 for/range 遍历像 然而，Go 1.23 版本之前不支持此特性。 对于 Go 1.23，我们决定同时支持对用户自定义容器类型的 for/range 遍历以及标准化形式的迭代器。 我们扩展了 for/range 语句以支持对函数类型进行范围遍历。我们将在下面看到这如何帮助遍历用户自定义容器。 我们还添加了标准库类型和函数来支持使用函数类型作为迭代器。迭代器的标准定义使我们能够编写与不同容器类型流畅协作的函数。 改进后的 for/range 语句不支持任意函数类型。从 Go 1.23 开始，它现在支持范围遍历接受单个参数的函数。该单个参数本身必须是一个接受零到两个参数并返回布尔值的函数；按照惯例，我们称之为 yield 函数。 当我们在 Go 中提到迭代器时，我们指的是具有这三种类型之一的函数。我们将在下面讨论，标准库中还有另一种迭代器：拉取迭代器（pull iterator）。当需要区分标准迭代器和拉取迭代器时，我们将标准迭代器称为推送迭代器（push iterators）。这是因为，正如我们将看到的那样，它们通过调用 yield 函数来推送一系列值。 为了使迭代器更易于使用，新的标准库包 iter 定义了两种类型： 通过示例来解释迭代器的工作原理最简单。这里 迭代器函数本身接受另一个函数作为参数，即 yield 函数。迭代器会用集合中的每个值调用 yield 函数。在这种情况下，由 这展示了迭代器如何工作：对于某个值序列，它们会用序列中的每个值调用一个 yield 函数。如果 yield 函数返回 false，表示不再需要更多值，迭代器就可以直接返回，执行可能需要的任何清理工作。如果 yield 函数从未返回 false，迭代器在用序列中的所有值调用 yield 后就可以直接返回。 这就是它们的工作原理，但我们得承认，当你第一次看到这些时，你的第一反应可能是“这里有很多函数在飞来飞去”。你没说错。让我们关注两件事。 第一点是，一旦你理解了函数代码的第一行，迭代器的实际实现就非常简单：用集合中的每个元素调用 yield 函数，如果 yield 返回 false 则停止。 第二点是，使用它非常简单。你调用 在这种代码中， 如果你仔细想想，你会发现编译器一定在调整循环以创建一个 yield 函数，并将其传递给由 我们现在已经看到了如何在 for/range 循环中使用迭代器。但是简单的循环并不是使用迭代器的唯一方式。例如，有时我们可能需要并行遍历两个容器。我们该如何实现呢？ 答案是我们使用另一种迭代器：拉取迭代器（pull iterator）。我们已经知道，标准迭代器，也称为推送迭代器（push iterator），是一个接受 yield 函数作为参数并通过调用 yield 函数推送序列中每个值的函数。 拉取迭代器则反向工作：它是一个被编写成每次调用时都会返回序列中下一个值的函数。 我们将重复这两种迭代器之间的区别，以帮助您记忆 您可以自己编写一个拉取迭代器，但通常不必这样做。新的标准库函数 由 另一种说法是，调用停止函数将导致 yield 函数在被推送迭代器调用时返回 false。 严格来说，如果拉取迭代器返回 false 表示已到达序列末尾，则不需要调用停止函数，但通常最好始终调用它，这样更简单。 这里是一个使用拉取迭代器并行遍历两个序列的例子。这个函数报告两个任意序列是否包含相同顺序的相同元素。 该函数使用 然后代码循环，调用拉取迭代器来检索值。如果第一个序列完成，则在第二个序列也完成时返回 true，否则返回 false。如果值不同，则返回 false。然后循环继续拉取接下来的两个值。 与推送迭代器一样，Go 运行时中存在一些复杂性以使拉取迭代器高效，但这不会影响实际使用 现在您已经了解了关于范围函数类型和迭代器的所有知识。希望您喜欢使用它们！ 不过，还有一些值得提及的事情。 迭代器标准定义的一个优点是能够编写使用它们的标准适配器函数。 例如，这是一个过滤值序列并返回新序列的函数。这个 与之前的例子一样，当您第一次看到函数签名时，它们看起来很复杂。一旦您理解了签名，实现就非常简单了。 代码遍历输入迭代器，检查过滤函数，并用应该进入输出迭代器的值调用 yield 函数。 我们将在下面展示使用 （目前 Go 标准库中没有 为了说明推送迭代器在遍历容器类型时有多方便，让我们考虑这个简单的二叉树类型。 我们不会展示将值插入树中的代码，但自然应该有某种方式可以遍历树中的所有值。 事实证明，如果迭代器代码返回一个 bool 值会更容易编写。由于 for/range 支持的函数类型不返回任何值，这里的 这展示了使用这种迭代器方法遍历即使是复杂数据结构也是如此简单。无需维护一个单独的栈来记录树中的位置；我们可以直接使用 goroutine 调用栈来为我们完成这项工作。 Go 1.23 中新增的还有 slices 和 maps 包中与迭代器一起使用的函数。 以下是 slices 包中新增的函数。 以下是 maps 包中新增的函数。 这里是一个示例，展示了如何将这些新函数与我们之前看到的 当然，您可以很容易地编写一个循环来完成此操作，而且在许多情况下，循环会更清晰。我们不希望鼓励每个人始终以这种风格编写代码。话虽如此，使用迭代器的好处是这类函数与任何序列都能以相同的方式工作。在这个例子中，请注意 Filter 如何使用 map 作为输入，使用 slice 作为输出，而无需对 Filter 中的代码进行任何更改。 尽管我们看到的大多数示例都涉及容器，但迭代器是灵活的。 考虑这段不使用迭代器的简单代码，用于遍历字节切片中的行。这段代码易于编写且相当高效。 然而， 这里是一个返回字节切片行迭代器的函数。在通常的迭代器签名之后，该函数非常简单。我们不断从数据中取出行，直到没有剩余，并将每一行传递给 yield 函数。 现在我们遍历字节切片行的代码看起来是这样的。 这与之前的代码一样易于编写，并且效率更高一些，因为它不需要分配一个行切片。 对于我们的最后一个例子，我们将看到您不必在 range 语句中使用推送迭代器。 之前我们看到了一个 没有特别的理由要这样写这段代码。这只是一个示例，表明 yield 函数并非魔术。它可以是您喜欢的任何函数。 最后一点说明：每个 Go 模块都会指定其使用的语言版本。这意味着为了在现有模块中使用新的语言特性，您可能需要更新该版本。这适用于所有新的语言特性，并非范围函数类型所特有。由于范围函数类型是 Go 1.23 版本中新增的，使用它需要指定至少 Go 语言版本 1.23。 设置语言版本的方法（至少有）四种runtime.CallersFrames 和 标准化方法
迭代器
Set 类型。for/range 语句
Set 类型这样的用户自定义容器，那将是一件不错的事情。此版本中的改进
范围遍历（部分）函数类型
func(yield func() bool)
func(yield func(V) bool)
func(yield func(K, V) bool)
标准（推送）迭代器
Seq 和 Seq2。这些是迭代器函数类型的名称，即可以与 for/range 语句一起使用的类型。名称 Seq 是 sequence（序列）的缩写，因为迭代器遍历一系列值。package iter
type Seq[V any] func(yield func(V) bool)
type Seq2[K, V any] func(yield func(K, V) bool)
// for now, no Seq0
Seq 和 Seq2 的区别仅在于 Seq2 是一个对序列，例如 map 中的键值对。为了简单起见，本文将重点关注 Seq，但我们讨论的大部分内容也适用于 Seq2。Set 方法 All 返回一个函数。All 的返回类型是 iter.Seq[E]，所以我们知道它返回一个迭代器。// All is an iterator over the elements of s.
func (s *Set[E]) All() iter.Seq[E] {
return func(yield func(E) bool) {
for v := range s.m {
if !yield(v) {
return
}
}
}
}
Set.All 返回的迭代器函数，与我们之前看到的 Set.Push 函数非常相似。 for v := range s.m {
if !yield(v) {
return
}
}
s.All 来获取一个迭代器，然后使用 for/range 来遍历 s 中的所有元素。for/range 语句支持任何迭代器，这显示了它多么容易使用。func PrintAllElements[E comparable](s *Set[E]) {
for v := range s.All() {
fmt.Println(v)
}
}
s.All 是一个返回函数的方法。我们调用 s.All，然后使用 for/range 遍历它返回的函数。在这种情况下，我们可以让 Set.All 本身就是一个迭代器函数，而不是让它返回一个迭代器函数。然而，在某些情况下这行不通，例如返回迭代器的函数需要接受参数，或者需要做一些设置工作。按照惯例，我们鼓励所有容器类型提供一个返回迭代器的 All 方法，这样程序员就不必记住是直接对 All 进行范围遍历，还是调用 All 来获取可以进行范围遍历的值。他们总是可以采用后一种方式。s.All 返回的迭代器。Go 编译器和运行时中存在相当多的复杂性来实现这一高效，并正确处理循环中的 break 或 panic 等情况。我们不会在这篇博客文章中介绍这些内容。幸运的是，在实际使用此特性时，实现细节并不重要。拉取迭代器
Set.Pull 方法的使用示例时就看到了这一点。iter.Pull 接受一个标准迭代器，也就是说，一个推送迭代器函数，并返回一对函数。第一个是拉取迭代器：一个函数，每次调用时返回序列中的下一个值。第二个是停止函数，当我们使用完拉取迭代器时应该调用它。这类似于我们之前看到的 Set.Pull 方法。iter.Pull 返回的第一个函数（拉取迭代器）返回一个值和一个布尔值，该布尔值报告该值是否有效。在序列末尾时，布尔值将为 false。iter.Pull 返回一个停止函数，以防我们没有读取到序列的末尾。在一般情况下，推送迭代器（iter.Pull 的参数）可能会启动 goroutine，或构建需要在迭代完成后清理的新数据结构。当 yield 函数返回 false 时，推送迭代器会进行任何清理工作，这意味着不再需要更多值。当与 for/range 语句一起使用时，for/range 语句将确保如果循环提前退出，无论是通过 break 语句还是其他任何原因，yield 函数都会返回 false。另一方面，对于拉取迭代器，无法强制 yield 函数返回 false，因此需要停止函数。// EqSeq reports whether two iterators contain the same
// elements in the same order.
func EqSeq[E comparable](s1, s2 iter.Seq[E]) bool {
next1, stop1 := iter.Pull(s1)
defer stop1()
next2, stop2 := iter.Pull(s2)
defer stop2()
for {
v1, ok1 := next1()
v2, ok2 := next2()
if !ok1 {
return !ok2
}
if ok1 != ok2 || v1 != v2 {
return false
}
}
}
iter.Pull 将两个推送迭代器 s1 和 s2 转换为拉取迭代器。它使用 defer 语句确保在使用完拉取迭代器后将其停止。iter.Pull 函数的代码。迭代器上的迭代
适配器
Filter 函数接受一个迭代器作为参数并返回一个新的迭代器。另一个参数是一个过滤函数，它决定了 Filter 返回的新迭代器中应该包含哪些值。// Filter returns a sequence that contains the elements
// of s for which f returns true.
func Filter[V any](f func(V) bool, s iter.Seq[V]) iter.Seq[V] {
return func(yield func(V) bool) {
for v := range s {
if f(v) {
if !yield(v) {
return
}
}
}
}
}
for v := range s {
if f(v) {
if !yield(v) {
return
}
}
}
Filter 的示例。Filter 函数，但在未来的版本中可能会添加。）二叉树
// Tree is a binary tree.
type Tree[E any] struct {
val E
left, right *Tree[E]
}
All 方法返回一个小的函数字面量，它调用迭代器本身（这里称为 push），并忽略 bool 结果。// All returns an iterator over the values in t.
func (t *Tree[E]) All() iter.Seq[E] {
return func(yield func(E) bool) {
t.push(yield)
}
}
// push pushes all elements to the yield function.
func (t *Tree[E]) push(yield func(E) bool) bool {
if t == nil {
return true
}
return t.left.push(yield) &&
yield(t.val) &&
t.right.push(yield)
}
push 方法使用递归遍历整个树，对每个元素调用 yield 函数。如果 yield 函数返回 false，该方法会在整个调用栈中返回 false。否则，一旦迭代完成，它就返回。新的迭代器函数。
All 和 Values 是返回切片元素迭代器的函数。Collect 从迭代器中获取值并返回一个包含这些值的切片。其他函数的详细信息请参阅文档。
All([]E) iter.Seq2[int, E]Values([]E) iter.Seq[E]Collect(iter.Seq[E]) []EAppendSeq([]E, iter.Seq[E]) []EBackward([]E) iter.Seq2[int, E]Sorted(iter.Seq[E]) []ESortedFunc(iter.Seq[E], func(E, E) int) []ESortedStableFunc(iter.Seq[E], func(E, E) int) []ERepeat([]E, int) []EChunk([]E, int) iter.Seq([]E)All、Keys 和 Values 返回 map 内容的迭代器。Collect 从迭代器中获取键和值并返回一个新的 map。
All(map[K]V) iter.Seq2[K, V]Keys(map[K]V) iter.Seq[K]Values(map[K]V) iter.Seq[V]Collect(iter.Seq2[K, V]) map[K, V]Insert(map[K, V], iter.Seq2[K, V])标准库迭代器示例
Filter 函数一起使用。这个函数接受一个从 int 到 string 的 map，并返回一个切片，其中只包含 map 中长度大于给定参数 n 的值。// LongStrings returns a slice of just the values
// in m whose length is n or more.
func LongStrings(m map[int]string, n int) []string {
isLong := func(s string) bool {
return len(s) >= n
}
return slices.Collect(Filter(isLong, maps.Values(m)))
}
maps.Values 函数返回一个对 m 中值的迭代器。Filter 读取该迭代器并返回一个只包含长字符串的新迭代器。slices.Collect 从该迭代器中读取值到新切片中。遍历文件中的行
nl := []byte{'\n'}
// Trim a trailing newline to avoid a final empty blank line.
for _, line := range bytes.Split(bytes.TrimSuffix(data, nl), nl) {
handleLine(line)
}
bytes.Split 会分配并返回一个字节切片组成的切片来存放行。垃圾回收器最终需要做一些工作来释放该切片。// Lines returns an iterator over lines in data.
func Lines(data []byte) iter.Seq[[]byte] {
return func(yield func([]byte) bool) {
for len(data) > 0 {
line, rest, _ := bytes.Cut(data, []byte{'\n'})
if !yield(line) {
return
}
data = rest
}
}
}
for line := range Lines(data) {
handleLine(line)
}
将函数传递给推送迭代器
PrintAllElements 函数，它可以打印出集合中的每个元素。这里还有另一种打印集合所有元素的方法：调用 s.All 获取一个迭代器，然后传入一个手动编写的 yield 函数。这个 yield 函数只打印一个值并返回 true。请注意，这里有两个函数调用：我们调用 s.All 获取一个迭代器（它本身就是一个函数），然后用我们手动编写的 yield 函数调用那个函数。func PrintAllElements[E comparable](s *Set[E]) {
s.All()(func(v E) bool {
fmt.Println(v)
return true
})
}
更新 go.mod 文件
go get go@1.23（或 go mod edit -go=1.23 只编辑 go 指令）。go.mod 文件并更改 go 行。//go:build go1.23 构建标签允许在特定文件中使用范围函数类型。
下一篇文章：新的 unique 包
上一篇文章：Go 1.23 已发布
博客索引