init project

codes/any.go

@@ -0,0 +1,17 @@
+package main
+
+// ANY OMIT
+// any is a type alias of empty interface
+type any = interface{}
+
+// ANY OMIT
+
+// PRINT OMIT
+// Print prints the elements of any slice.
+// Print has a type parameter T and has a single (non-type)
+// parameter s which is a slice of that type parameter.
+func Print[T interface{}](s []T) {
+	// same as above
+}
+
+// PRINT OMIT

codes/comparable.go

@@ -0,0 +1,27 @@
+package main
+
+// COMPARABLE EXAMPLE OMIT
+// Index returns the index of x in s, or -1 if not found.
+func Index[T comparable](s []T, x T) int {
+	for i, v := range s {
+		// v and x are type T, which has the comparable
+		// constraint, so we can use == here.
+		if v == x {
+			return i
+		}
+	}
+	return -1
+}
+
+// COMPARABLE EXAMPLE OMIT
+
+
+// ComparableHasher OMIT
+// ComparableHasher is a type constraint that matches all
+// comparable types with a Hash method.
+type ComparableHasher interface {
+	comparable
+	Hash() uintptr
+}
+
+// ComparableHasher OMIT

codes/generic_stack.go

@@ -0,0 +1,37 @@
+package main
+
+// STACK OMIT
+type Stack[T any] []T
+
+type Node[T any] struct {
+	val T
+}
+
+// STACK OMIT
+
+// INTSTACK OMIT
+var stack Stack[int]       // underlying type: []int
+var stack = Stack{1, 2, 3} // INVALID: cannot use generic type Stack[T any] without instantiation
+// INTSTACK OMIT
+
+// TYPE OMIT
+// make
+var stack = make(Stack[int])
+// new
+var stack = new(Stack[int])
+// 强制类型转换
+var stack = Stack[int]{1, 2, 3}
+var intStack []int = []int(stack)
+
+// TYPE OMIT
+
+// METHOD OMIT
+func (s *Stack[T]) Push(v T) { *s = append(*s, v) }
+
+func (s *Stack[T]) Pop() T {
+	v := *s[len(*s)-1]
+	*s = *s[:len(*s)-1]
+	return v
+}
+
+// METHOD OMIT

codes/graph.go

@@ -0,0 +1,32 @@
+
+package main
+
+
+// GRAPH OMIT
+// NodeConstraint is the type constraint for graph nodes:
+// they must have an Edges method that returns the Edge's
+// that connect to this Node.
+type NodeConstraint[Edge any] interface {
+	Edges() []Edge
+}
+
+// EdgeConstraint is the type constraint for graph edges:
+// they must have a Nodes method that returns the two Nodes
+// that this edge connects.
+type EdgeConstraint[Node any] interface {
+	Nodes() (from, to Node)
+}
+
+// Graph is a graph composed of nodes and edges.
+type Graph[Node NodeConstraint[Edge], Edge EdgeConstraint[Node]] struct { ... }
+
+// New returns a new graph given a list of nodes.
+func New[Node NodeConstraint[Edge], Edge EdgeConstraint[Node]] (nodes []Node) *Graph[Node, Edge] {
+	...
+}
+
+// ShortestPath returns the shortest path between two nodes,
+// as a list of edges.
+func (g *Graph[Node, Edge]) ShortestPath(from, to Node) []Edge { ... }
+
+// GRAPH OMIT

codes/method.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+// START OMIT
+type P[T any] struct{}
+
+func (p *P[T]) Say[S any](v S) { fmt.Println(v) }
+
+type T struct{}
+
+func (t *T) Say[S any](v S) { fmt.Println(v) }
+
+func main() {
+	var t T
+	t.Say[int](1)
+
+	/** output:
+	method.go:8:19: methods cannot have type parameters
+	method.go:8:20: invalid AST: method must have no type parameters
+	method.go:12:16: methods cannot have type parameters
+	method.go:12:17: invalid AST: method must have no type parameters
+	*/
+}
+
+// END OMIT

codes/node.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+// NODE OMIT
+type Node[T any] struct {
+	next *Node[T]
+	val  T
+}
+
+func main() {
+	var a = Node[string]{next: &Node[string]{}, val: "ssss"}
+	fmt.Println(a)
+}
+
+// NODE OMIT

codes/operator.go

@@ -0,0 +1,42 @@
+package main
+
+// MIN OMIT
+func Min[T any](s []T) T {
+	r := s[0] // assume that s is not empty
+	for _, v := range s {
+		if v < r { // INVALID
+			r = v
+		}
+	}
+	return r
+}
+
+// MIN OMIT
+
+
+
+// OPERATOR CONSTRAINT OMIT
+
+// Ordered is a type constraint that matches any ordered type.
+// An ordered type is one that supports the <, <=, >, and >= operators.
+type Ordered interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64 |
+		~string
+}
+
+// OPERATOR CONSTRAINT OMIT
+
+// OPERATOR MIN OMIT
+func Min[T Ordered](s []T) T {
+	r := s[0] // assume that s is not empty
+	for _, v := range s {
+		if v < r { // INVALID
+			r = v
+		}
+	}
+	return r
+}
+
+// OPERATOR MIN OMIT

codes/stack.go

@@ -0,0 +1,14 @@
+package main
+
+// STACK OMIT
+type Stack []interface{}
+
+func (s *Stack) Push(v interface{}) { *s = append(*s, v) }
+
+func (s *Stack) Pop() interface{} {
+	v := *s[len(*s)-1]
+	*s = *s[:len(*s)-1]
+	return v
+}
+
+// STACK OMIT

codes/stringify.go

@@ -0,0 +1,11 @@
+package main
+
+//  STRINGER OMIT
+// Stringer is a type constraint that requires the type argument to have
+// a String method and permits the generic function to call String.
+// The String method should return a string representation of the value.
+type Stringer interface {
+	String() string
+}
+
+// STRINGER OMIT

codes/type_sets.go

@@ -0,0 +1,66 @@
+package main
+
+// TYPE OMIT
+type Integer interface {
+	int
+}
+
+// TYPE OMIT
+
+// INVALID OMIT
+// EmbeddedParameter is INVALID.
+type EmbeddedParameter[T any] interface {
+	T // INVALID: may not list a plain type parameter
+}
+// INVALID OMIT
+
+
+// APPRO OMIT
+type MyInt int 
+
+type AnyInteger interface {
+	~int 
+}
+// APPRO OMIT
+
+
+// ALL INVALID OMIT
+
+type MyString string 
+
+// ApproximateMyString is INVALID.
+type ApproximateMyString interface {
+	~MyString // INVALID: underlying type of MyString is not MyString
+}
+
+// ApproximateParameter is INVALID.
+type ApproximateParameter[T any] interface {
+	~T // INVALID: T is a type parameter
+}
+
+type MyInterface {}
+
+// ApproximateInterface is INVALID.
+type ApproximateInterface interface {
+	~MyInterface // INVALID: T is an interface type
+}
+
+// ALL INVALID OMIT
+
+
+
+
+// ONION EXAMPLE OMIT
+
+// PredeclaredSignedInteger is a constraint that matches the
+// five predeclared signed integer types.
+type PredeclaredSignedInteger interface {
+	int | int8 | int16 | int32 | int64
+}
+
+// SignedInteger is a constraint that matches any signed integer type.
+type SignedInteger interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// ONION EXAMPLE OMIT

codes/use_constraints.go

@@ -0,0 +1,34 @@
+package main
+
+// STR OMIT
+// Stringify calls the String method on each element of s,
+// and returns the results.
+func Stringify[T Stringer](s []T) (ret []string) {
+	for _, v := range s {
+		ret = append(ret, v.String())
+	}
+	return ret
+}
+
+// STR OMIT
+
+// PRT OMIT
+// Print2 has two type parameters and two non-type parameters.
+func Print2[T1, T2 any](s1 []T1, s2 []T2) { /**...*/ }
+
+// PRT OMIT
+
+// CONCAT OMIT
+type Stringer interface{ String() string }
+
+type Plusser interface{ Plus(string) string }
+
+func ConcatTo[S Stringer, P Plusser](s []S, p []P) []string {
+	r := make([]string, len(s))
+	for i, v := range s {
+		r[i] = p[i].Plus(v.String())
+	}
+	return r
+}
+
+// CONCAT OMIT

go.mod

@@ -0,0 +1,10 @@
+module go-generic
+
+go 1.17
+
+require (
+	github.com/yuin/goldmark v1.4.1 // indirect
+	golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f // indirect
+	golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 // indirect
+	golang.org/x/tools v0.1.8 // indirect
+)

go.sum

@@ -0,0 +1,8 @@
+github.com/yuin/goldmark v1.4.1 h1:/vn0k+RBvwlxEmP5E7SZMqNxPhfMVFEJiykr15/0XKM=
+github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f h1:OfiFi4JbukWwe3lzw+xunroH1mnC1e2Gy5cxNJApiSY=
+golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 h1:id054HUawV2/6IGm2IV8KZQjqtwAOo2CYlOToYqa0d0=
+golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w=
+golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=

main.slide

@@ -0,0 +1,238 @@
+# Go generic
+Qinghe
+21 Jan 2022
+
+## Defining constraints
+constraints的作用：
+- 规定一些类型参数可以调用的方法
+
+interface即可满足上面的需求，因此继续沿用interface类型来定义一个constraint。
+
+还是以Stringify为例，定义一个constraint:
+
+
+.code codes/stringify.go /STRINGER OMIT/,/STRINGER OMIT/
+
+- 与接口定义一样，定义一些方法集
+- 类型参数必须实现interface
+
+
+## any constraints
+
+- any是一个constraint，表示类型参数可以是任何类型
+- constraint是个interface类型，类型参数必须实现interface
+
+推断出
+
+.code codes/any.go /ANY OMIT/,/ANY OMIT/
+
+
+**any的本质是个空的interface**
+
+
+- any一开始被设计为只允许用在泛型中的类型约束上，后续经社区讨论修改后可代替interface{}用在任何地方 [issue#33232](https://github.com/golang/go/issues/33232)
+- any是个预定义类型，和int、string等类似
+- 可以被覆盖，不会影响兼容性
+
+
+## Using a constraint
+
+- 单个类型参数
+
+.code codes/use_constraints.go /STR OMIT/,/STR OMIT/
+
+
+## Using a constraint
+多个类型参数
+
+- 相同约束
+
+.code codes/use_constraints.go /PRT OMIT/,/PRT OMIT/
+
+- 不同约束
+
+.code codes/use_constraints.go /CONCAT OMIT/,/CONCAT OMIT/
+
+## Generic types
+
+## Generic types
+
+不光有泛型函数，也有泛型类型，在定义一些通用类型时可以用到。
+
+
+.code codes/generic_stack.go /STACK OMIT/,/STACK OMIT/
+
+在使用泛型类型时，必须提供类型实参，这一操作被称为「类型实例化」。
+
+.code codes/generic_stack.go /INTSTACK OMIT/,/INTSTACK OMIT/
+
+其他使用和普通类型没有区别
+
+.code codes/generic_stack.go /TYPE OMIT/,/TYPE OMIT/
+
+## Generic types 
+泛型类型和一般类型一样，也可以定义方法。
+
+.code codes/generic_stack.go /METHOD OMIT/,/METHOD OMIT/
+
+- 声明方法时，receiver类型的类型参数**必须**与声明receiver类型时定义的参数**个数相同**
+- 方法的类型参数实参名称和类型定义时的类型参数形参**名称不需要相同**，在方法中没有使用到类型时，名称可以为 "_"
+- 类型参数后面**没有**constraints
+
+## Generic types 
+方法的声明中，不能包含类型参数。以下代码均编译不通过：
+
+.play codes/method.go /START OMIT/,/END OMIT/
+
+至于原因，请见后续。
+
+## Operators
+
+
+## Operators
+由前面的例子可以看出，使用interface作为constraints时，只规定了一系列可调用的方法集。
+到目前为止，泛型方法能够做的事情，除了任何类型都能做的事情外，也就只有
+方法调用了。
+
+但是方法调用并不能够完美实现某些需求。如下：
+
+.code codes/operator.go /MIN OMIT/,/MIN OMIT/
+
+
+不是所有的类型都支持`<`操作符，而且`<`不是一个方法，无法通过interface来实现。
+
+## Operators
+
+- 除了两种例外情况（后面会将），所有的四则运算、大小比较、逻辑运算只允许被用在预定义类型或者底层为预定义类型的自定义类型中。
+- instead of saying which operators a constraint should support, we can say which types a constraint should accept. We do this by defining a type set for a constraint.
+
+
+## Type sets
+
+## Type sets
+
+todo
+
+## Constraint elements
+在interface类型中额外定义一些元素作为约束，这些元素包括：
+
+- 具体类型
+- 近似类型
+- 联合类型
+
+## Arbitrary type constraint element
+
+可以在interface中嵌入任意类型
+
+.code codes/type_sets.go /TYPE OMIT/,/TYPE OMIT/
+
+但是，类型不能是type parameter
+
+.code codes/type_sets.go /INVALID OMIT/,/INVALID OMIT/
+
+
+## Approximation constraint element(近似类型)
+
+**定义类型和非定义类型（defined type and undefined type）**
+
+一个定义类型是一个在某个类型定义声明中定义的类型。
+
+所有的基本类型都是定义类型。一个非定义类型一定是一个组合类型。
+
+**底层类型（underlying type）**
+
+在Go中，每个类型都有一个底层类型。规则：
+- 一个内置基本类型的底层类型为它自己。
+- unsafe标准库包中定义的Pointer类型的底层类型是它自己。（至少我们可以认为是这样。事实上，关于unsafe.Pointer类型的底层类型，官方文档中并没有清晰的说明。我们也可以认为unsafe.Pointer类型的底层类型为*T，其中T表示一个任意类型。）
+- 一个非定义类型（必为一个组合类型）的底层类型为它自己。
+- 在一个类型声明中，新声明的类型和源类型共享底层类型。
+
+来源： [go101#类型系统概述](https://gfw.go101.org/article/type-system-overview.html)
+
+## Approximation constraint element
+
+如果某个类型T1，底层类型为类型T2，则这个类型T1被称为类型T2的近似类型。一个类型的近似类型可以有多个，这些所有的近似类型集合可以
+用符号`~`来表示。
+
+例如：
+
+.code codes/type_sets.go /APPRO OMIT/,/APPRO OMIT/
+
+约束AnyInteger表示的类型集为所有底层类型为int的类型，其中包括MyInt类型，因此MyInt可以作为type argument参数。
+
+因为~T表示所有底层类型为T的类型，当然类型T的底层类型也应该是自己，满足这个条件的类型有：
+- 非定义类型
+- 大部分预定义类型，比如int或者string(不包括error类型)
+
+## Approximation constraint element
+在近似类型中，类型T不能为类型参数或者interface类型。
+
+.code codes/type_sets.go /ALL INVALID OMIT/,/ALL INVALID OMIT/
+
+## Union constraint element(联合类型)
+
+
+## Union constraint element
+第三种允许使用的约束元素是**联合类型**。这是一种新的语法结构，用竖线（|）将一系列约束元素分隔。联合类型所代表的类型集是各约束元素类型集的并集，并且各
+约束元素不可以重复。
+
+.code codes/type_sets.go /ONION EXAMPLE OMIT/,/ONION EXAMPLE OMIT/
+
+
+## Operations based on type sets
+
+提出type sets的目的就是允许泛型函数使用'<'、'>'之类的运算符。
+
+泛型函数中允许的操作是type sets中所有的类型都允许的操作。因此，一般来说，**约束中
+包括的类型越多，那么允许的操作就越少，包括的类型越少，则允许的操作就越多**。
+
+## Operations based on type sets
+
+回过头再来看之前的`Min`函数的例子，可以使用如下的约束：
+
+.code codes/operator.go /OPERATOR CONSTRAINT OMIT/,/OPERATOR CONSTRAINT OMIT/
+
+现在，下面的代码就可以运行了
+
+.code codes/operator.go /OPERATOR MIN OMIT/,/OPERATOR MIN OMIT/
+
+## Comparable types in constraints
+
+之前我们说，操作符只能被用于语言预定义的类型或底层类型为语言预定义类型的类型之间，但是有两个例外，这两个例外就是`==`和`!=`。
+
+这两个操作符允许被用在struct、array和接口类型之间。但是我们无法定义一个约束，用来包含这些所有可以进行比较的类型。
+
+## Comparable types in constraints
+
+因此，设计了一个内置的约束：`comparable`。这个约束所包含的类型集为所有可以进行`==`和`!=`操作的类型。
+
+例如：
+
+.code codes/comparable.go /COMPARABLE EXAMPLE OMIT/,/ COMPARABLE EXAMPLE OMIT/
+
+
+## Comparable types in constraints
+
+comparable作为一个约束，它也可以被嵌入在其他约束内。
+
+.code codes/comparable.go /ComparableHasher OMIT/,/ComparableHasher OMIT/
+
+满足上面约束的类型必须满足两个条件：
+- 必须可以比较
+- 必须有Hash() uintptr方法
+
+
+
+## Mutually referencing type parameters（相互引用类型参数）
+
+在一个泛型函数的定义中，类型参数之间可能会相互引用。
+
+例如，要实现图数据结构的一些基本算法。图包括两种结构，`Node`和`Edge`,`Node`应该有个方法Egdes()[]Edge，用于返回和节点相连的边。Edge也有个方法
+Nodes()(Node,Node)，用于返回一条边两端连接的节点。一个完整的图就可以用[]Node来表示。
+
+
+## Mutually referencing type parameters
+
+代码如下：
+
+.code codes/graph.go /GRAPH OMIT/,/GRAPH OMIT/