Generics

泛型，也被称为类型参数，允许定义结构体或方法时，传入的参数类型不固定，运行时，可传入不同类型的参数。

func MapKeys[K comparable, V any](m map[K]V) []K {
	r := make([]K, 0, len(m))
	for k := range m {
		r = append(r, k)
	}
	return r
}

该方法从任何类型的映射中取出键名。
该方法有两个类型参数：K和V，分别对应作为参数的映射的键名和键值的类型。
该方法返回一个切片，切片的类型和映射参数的键名的类型相同。

var m1 = map[int]string{1: "2", 2: "4", 4: "8"}
fmt.Println("keys m:", MapKeys(m1))
var m2 = map[string]string{"a": "2", "b": "4", "c": "8"}
fmt.Println("keys m:", MapKeys(m2))

map[1001:Aaron 1002:Ab 1003:Abbas 1004:Abbot] with keys: [1001 1002 1003 1004]
map[Aaron:doctor Ab:nurse Abbas:teacher Abbot:police] with keys: [Aaron Ab Abbas Abbot]

我们也可以明确的指定类型参数，虽然没必要。

var m = map[int]string{1001: "Aaron", 1002: "Ab", 1003: "Abbas", 1004: "Abbot"}
fmt.Println(m, "with keys:", MapKeys[int, string](m1))

map[1001:Aaron 1002:Ab 1003:Abbas 1004:Abbot] with keys: [1001 1002 1003 1004]

type Element[T any] struct {
	val  T
	next *Element[T]
}

type List[T any] struct {
	head, tail *Element[T]
}

这是一个链表，链表里可放不同类型的元素。

func (lst *List[T]) Push(v T) {
	if lst.tail == nil {
		lst.head = &Element[T]{val: v}
		lst.tail = lst.head
	} else {
		lst.tail.next = &Element[T]{val: v}
		lst.tail = lst.tail.next
	}
}

func (lst *List[T]) GetAll() []T {
	var elems []T
	for e := lst.head; e != nil; e = e.next {
		elems = append(elems, e.val)
	}
	return elems
}

这里定义了链表的方法，分别用于追加元素和获取所有元素。
从这里可以看出，链表的类型是List[T]。

lst := List[int]{}
lst.Push(10)
lst.Push(13)
lst.Push(23)
fmt.Println("list:", lst.GetAll())

list: [10 13 23]