Go 正在发生变化？从泛型到迭代器的爱恨

大家好，我是煎鱼。

前段时间 Kris Brandow 和嘉宾 Ian Lopshire 在播客中针对《Go 的发展方向错了吗？》这个命题进行了深入讨论，还探讨了 Go 语言的最新变化及其发展方向，重点涉及泛型和新版本加入的迭代器功能。

社区对这些特性的反应各不相同：

1、一些开发者认为增加的新特性违背了 Go 语言原本简洁的设计理念。

2、另一些则期待这些功能为开发带来的灵活性和便利性。

本文将结合两位嘉宾的观点，深入分析这些功能背后的技术细节及其对 Go 语言生态系统的影响。

泛型：必要的复杂性

Go 语言一直以来因其简单和一致性备受赞誉，但随着应用场景的拓宽和开发需求的增加，语言的功能扩展变得不可避免。

泛型作为 Go 1.18 版本中最重要的新增特性，显著地丰富了开发者的工具箱，也因此引起了社区内外的广泛关注与讨论。

一个简单的泛型例子：

// Stack 使用泛型定义一个栈数据结构
type Stack[T any] struct {
 elements []T
}

// Push 将元素压入栈中
func (s *Stack[T]) Push(element T) {
 s.elements = append(s.elements, element)
}

// Pop 从栈中弹出元素
func (s *Stack[T]) Pop() (T, bool) {
 if len(s.elements) == 0 {
  var zero T
  return zero, false
 }
 index := len(s.elements) - 1
 element := s.elements[index]
 s.elements = s.elements[:index]
 return element, true
}

func main() {
 // 创建一个整数类型的栈
 intStack := Stack[int]{}
 intStack.Push(10)
 intStack.Push(20)
 fmt.Println(intStack.Pop()) // 输出: 20, true
 fmt.Println(intStack.Pop()) // 输出: 10, true

 // 创建一个字符串类型的栈
 stringStack := Stack[string]{}
 stringStack.Push("Hello")
 stringStack.Push("Go")
 fmt.Println(stringStack.Pop()) // 输出: Go, true
 fmt.Println(stringStack.Pop()) // 输出: Hello, true
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.

输出结果：

20 true
10 true
Go true
Hello true
1.
2.
3.
4.

Ian 的看法：Ian 认为，泛型的引入确实增加了语言的复杂性，但这一功能的加入是必需的。他指出，尽管泛型的概念增加了学习门槛，但在很多常见场景中，泛型的使用不会显得过于突兀。

他提到，泛型的最大优势在于代码的复用性和灵活性，特别是在构建复杂的数据结构或工具库时，泛型能显著减少冗余代码，从而提升开发效率。

例如，使用泛型可以避免为不同数据类型编写重复的代码，实现了一种“写一次，适用多处”的效果。

Ian 的观点与社区的主流态度一致，开发者们普遍认为泛型虽然复杂，但它带来的优势也是显而易见的。在一个高效的编程语言中，泛型的支持使得 Go 的应用场景更为广泛，适用于更多复杂的项目和需求。

迭代器：标准化的挑战

Go 1.23 版本将要加入的迭代器功能再次引起了人们对语言复杂性的讨论。

迭代器可以提供一种标准化的遍历集合数据的方法，有助于增强 Go 在数据处理方面的能力。

然而，如何平衡这种增强功能与语言的简洁性是 Go 设计者们所面临的核心挑战。

一个简单的迭代器例子：

func Backward[E any](s []E "E any") iter.Seq2[int, E] {
 return func(yield func(int, E) bool) {
  for i := len(s) - 1; i >= 0; i-- {
   if !yield(i, s[i]) {
    return
   }
  }
 }
}

func main() {
 sl := []string{"脑子", "进", "煎鱼", "了"}
 for i, s := range Backward(sl) {
  fmt.Printf("%d: %s\n", i, s)
 }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

输出结果：

3: 了
2: 煎鱼
1: 进
0: 脑子
1.
2.
3.
4.

Kris 的意见：Kris 对 Go1.23 加入的迭代器功能持谨慎乐观的态度。他指出，尽管迭代器提供了一种优雅的解决方案，尤其是在处理大型数据集合或流式数据时非常有效，但其函数签名的复杂性和潜在的学习曲线让他感到担忧。

他认为，标准化的迭代器或许能够减少开发者在处理不同数据结构时的心智负担，但必须确保这一特性不会偏离 Go 简洁的设计哲学。

使用场景：在数据科学或机器学习领域，迭代器是一种常见的模式，能够高效地遍历大量数据，进行批量处理或数据流分析。迭代器的引入无疑拓展了 Go 的应用边界，使其能够更好地胜任此类需求。

Go 未来方向：复杂性与简洁性的平衡

Go 语言的发展一直遵循着一条清晰的设计哲学，即 “简洁优先”。

然而，随着需求的变化和用户数量的增长，Go 的设计团队也在不断权衡如何在保留语言简洁性的同时，为开发者提供更多的工具和灵活性。

在讨论中，Kris 和 Ian 一致认为，语言功能的增加不可避免会引入一些复杂性，而这种复杂性是否值得取决于其带来的实际价值。在泛型和迭代器的案例中，我们看到的是一种 “有条件的妥协”。

泛型和迭代器的加入标志着 Go 的一个新阶段，它不再只是一个适用于简单、高效系统的工具，而是向更广泛的应用场景进发。

Go 的设计团队在这一过程中始终保持审慎态度，以确保每一个新特性都能够在提升语言功能的同时，尽量不违背其初衷。

总结

泛型和迭代器的引入无疑为 Go 增添了新的可能性，使其在处理复杂项目和数据密集型应用时更加得心应手。与此同时，这些特性也提出了新的挑战，即如何在不影响开发体验的前提下保持语言的简洁和一致性。

Kris 和 Ian 的讨论反映了 Go 社区的一种共识：Go 的发展需要与时俱进，但在增加新功能的同时，必须始终铭记语言的核心设计理念。

未来，我们可以期待 Go 语言在更多领域中展现其潜力，同时也继续在简洁性与功能性之间找到理想的平衡点。