feature: 分chapter

chapter1-why-generics.slide

@@ -0,0 +1,130 @@
+# Go 泛型介绍
+
+清和
+2022-01-22
+chenqh721@foxmail.com
+
+
+## Agenda
+- Why generic
+- Type parameter
+- Constraint
+- Some cases
+
+
+## Why generic
+
+## Why generic
+
+.code codes/atomic.go /OMIT/,/OMIT/
+
+- 每种类型都得实现一遍
+
+## Why generic
+
+.code codes/atomic.go /INTR OMIT/,/INTR OMIT/
+
+- 无法在编译期检查出错误
+- 类型转换影响性能
+
+
+## Type parameters
+
+## Type parameters
+
+泛型代码中会用到抽象的数据类型，这个类型叫做`type parameters`. 在运行泛型代码的时候，类型形参会被替换为类型实参。
+
+.code codes/print.go /PRINT OMIT/,/PRINT OMIT/
+
+类型T该如何被定义？
+
+
+- 类型参数类似于传统的非类型参数
+- 需要区分类型参数与非类型参数
+
+==>  **需要另外一个可选参数列表来确定类型参数**
+
+
+## Type parameter
+
+- 在普通参数前面
+- 使用方括号[ ]包围
+- 类型参数也有「元类型」，也即constraint（约束）
+
+.code codes/print.go /GEN OMIT/,/GEN OMIT/
+
+以上示例代码中：
+
+- `T` 是一个**type parameter**
+- **any**是一个**constraint**，意思是T可以是任意类型
+- `T` 可以用来规定参数s的类型，也可以用在函数体内
+- 不同于普通参数，类型参数名`T` 不可省略
+
+## Type parameter
+
+调用泛型函数
+
+.play codes/print.go /CALL OMIT/,/CALL OMIT/
+
+- 需指定类型参数，类型参数写在中括号内
+- 有多个类型参数时，使用逗号分隔
+
+
+## Constraint
+
+## Constraint
+接下来来个稍微复杂点的例子：
+
+.play codes/stringfy.go /START OMIT/,/END OMIT/
+
+- T 可以是任意类型
+- 类型 T 可能并没有String方法
+
+**以上代码并不能运行**
+
+
+## Constraint
+
+在其他有泛型的语言中也会出现类似的情况。
+
+例如，在C++中。
+
+调用v.String()是允许的，在编译过程中，如果发现实际调用时传入的类型实参T没有String方法，那么会报错误，如果有String方法，可以正常编译。
+
+也就是说：**C++实际上对类型是没有明确限制的**
+
+
+## Constraint
+
+出于语言风格考虑，Go语言不会采用上述方案。
+
+- In Go we don't refer to names, such as, in this case, String, and hope that they exist. Go resolves all names to their declarations when they are seen.
+- Another reason is that Go is designed to support programming at scale.
+
+Details see: [Type Parameters Proposal # Constraint](https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md#constraints)
+
+通常，我们希望泛型代码中的类型参数满足一定的条件，这些条件被称为约束（Constraints）。
+
+Constraints必须能够同时限制调用方传入的类型参数以及泛型函数的具体实现：
+1. **调用泛型函数时传入的类型实参必须满足Constraints**
+2. **实现泛型函数时必须用Constraints允许的方式来使用这些值(e. g. + - * / > ....)**
+
+
+## Constraint
+
+首先看一个特殊的constraint：**any**，表示类型参数允许是任何类型。any约束下各类型（T）允许的操作有：
+
+- 申明对应类型的变量
+- 给此类型变量重新赋一个相同类型的值
+- 将此类型变量传给其他函数或者作为返回值返回
+- 取此类型变量的地址
+- 强制类型转换为interface{}类型或者赋值给interface{}类型的变量
+- 将类型T强转为类型T(允许但是没啥用)
+- 使用类型断言将interface转换为类型T
+- 在type switch中使用此类型作为其中一个case
+- 定义及使用此类型的复合类型（例如切片）
+- 将此类型作为预定义类型的参数，比如new函数
+
+## Constraint
+
+

main.slide → chapter2-constraints.slide

@@ -222,17 +222,57 @@ comparable作为一个约束，它也可以被嵌入在其他约束内。
 - 必须有Hash() uintptr方法
 
 
+## Type inference（类型推断）
 
-## Mutually referencing type parameters（相互引用类型参数）
+## Type inference
+可以使用约束类型推断来省略一些代码。在实例化泛型函数或类型时，可以省略部分或全部类型参数。当省略的类型参数可以被推断时，如果只指定部分类型实参，
+则这部分类型实参是类型形参的第一个参数。
 
-在一个泛型函数的定义中，类型参数之间可能会相互引用。
+举例如下：
 
-例如，要实现图数据结构的一些基本算法。图包括两种结构，`Node`和`Edge`,`Node`应该有个方法Egdes()[]Edge，用于返回和节点相连的边。Edge也有个方法
-Nodes()(Node,Node)，用于返回一条边两端连接的节点。一个完整的图就可以用[]Node来表示。
+.code codes/type_inference.go /MAP OMIT/,/MAP OMIT/
 
+以下的调用方式都是正确的：
 
-## Mutually referencing type parameters
 
-代码如下：
+.code codes/type_inference.go /MAP CALL OMIT/,/MAP CALL OMIT/ 
 
-.code codes/graph.go /GRAPH OMIT/,/GRAPH OMIT/
+## Type inference
+
+当类型不能被推断的时候，省略类型参数会报错。
+
+//例如：
+
+//.code codes/type_inference.go /ERR OMIT/,/ERR OMIT/
+
+
+## Type unification (类型归并)
+
+类型推断的基础是类型归并。类型归并用于两种类型之间，描述一种类型是否包含在另一种类型中。其中至少一种是类型参数或者包含类型参数。
+
+类型归并比较类型间的结构，如果除了类型参数以外的部分结构和类型一致，则可以成功归并。
+
+
+举个例子：
+
+如果T1和T2是类型参数，[]map[int]bool可以被归并为以下方式：
+- []map[int]bool
+- T1 (T1 matches []map[int]bool)
+- []T1 (T1 matches map[int]bool)
+- []map[T1]T2 (T1 matches int, T2 matches bool)
+
+（上述列表并不完全，可能存在其他归并方式）
+
+## Type unification
+
+
+
+对于[]map[int]bool类型，以下方式就是错误的归并方式：
+- int
+- struct{}
+- []struct{}
+- []map[T1]string
+
+
+## Function argument type inference
+函数参数类型推断用在进行函数调用并且没有指明类型参数时。当类型参数在实例化

codes/atomic.go

@@ -0,0 +1,41 @@
+package example
+
+// OMIT
+func AddInt32(addr *int32, delta int32) int32 {
+	// some codes ...
+	return 0
+}
+func AddInt64(addr *int64, delta int64) int64 {
+	// some codes ...
+	return 0
+}
+func AddUint32(addr *uint32, delta uint32) uint32 {
+	// some codes ...
+	return 0
+}
+func AddUint64(addr *uint64, delta uint64) uint64 {
+	// some codes ...
+	return 0
+}
+
+// OMIT
+
+// INTR OMIT
+func Add(addr interface{}, delta interface{}) interface{} {
+	switch addr.(type) {
+	case nil:
+		// some codes
+	case *int32:
+		// some codes
+	case *int64:
+		// some codes
+	case *uint32:
+		// some codes
+	case *uint64:
+		// some codes
+	}
+
+	return nil
+}
+
+// INTR OMIT

codes/graph.go

@@ -1,32 +0,0 @@
-
-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/print.go

@@ -0,0 +1,31 @@
+package main
+
+import "fmt"
+
+/**
+// PRINT OMIT
+func Print(s []T) {
+	for _, v := range s {
+		fmt.Println(v)
+	}
+}
+
+// PRINT OMIT
+**/
+
+
+// GEN OMIT
+func Print[T any](s []T) {
+	for _, v := range s {
+		fmt.Println(v)
+	}
+}
+// GEN OMIT
+
+
+func main(){
+	// CALL OMIT
+	Print[int]([]int{1,2,3,4})
+	Print[int32](int32{1,2,3,4})
+	// CALL OMIT
+}

codes/stringfy.go

@@ -0,0 +1,17 @@
+package main
+
+
+func main(){
+	Stringify([]int{1,2,3})
+}
+
+// START OMIT
+// Stringify convert a slice of type T to a string slice.
+func Stringify[T any](s []T) (ret []string) {
+	for _, v := range s {
+		ret = append(ret, v.String())
+	}
+	return ret
+}
+
+// END OMIT

codes/type_inference.go

@@ -0,0 +1,30 @@
+
+// MAP OMIT
+func Map[F, T any](s []F, f func(F) T) []T { ... }
+// MAP OMIT
+
+
+// MAP CALL OMIT
+var s []int
+f := func(i int) int64 { return int64(i) }
+var r []int64
+// Specify both type arguments explicitly.
+r = Map[int, int64](s, f)
+// Specify just the first type argument, for F,
+// and let T be inferred.
+r = Map[int](s, f)
+// Don't specify any type arguments, and let both be inferred.
+r = Map(s, f)
+
+// MAP CALL OMIT
+
+
+// ERR OMIT
+
+func Double[T interface{ ~int }](v T) T { 
+	return v * 2 
+}
+
+Double(1) // 
+
+// ERR OMIT