2022-04-01 23:19

chapter1-why-generics.slide

@@ -41,7 +41,7 @@ https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-param
 
 .code codes/atomic.go /INTR OMIT/,/INTR OMIT/
 
-- 需要写很多”无用“代码
+- 需要写很多脏代码
 - 无法在编译期检查出错误
 - 类型转换影响性能
 
@@ -65,7 +65,7 @@ https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-param
 - 使用方括号[ ]包围
 - 类型参数也有「元类型」，也即constraint（约束）
 
-.code codes/print.go /GEN OMIT/,/GEN OMIT/
+.code -edit codes/print.go /GEN OMIT/,/GEN OMIT/
 
 以上示例代码中：
 
@@ -106,7 +106,7 @@ https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-param
 
 调用v.String()是允许的，在编译过程中，如果发现实际调用时传入的类型实参T没有String方法，那么会报错误，如果有String方法，可以正常编译。
 
-也就是说：**C++实际上对类型是没有明确限制的**
+也就是说：**C++实际上对传入类型是没有明确限制的**
 
 
 ## Constraint
@@ -125,21 +125,9 @@ Constraints必须能够同时限制调用方传入的类型参数以及泛型函
 2. **实现泛型函数时必须用Constraints允许的方式来使用这些值(e. g. + - * / > ....)**
 
 
-## Constraint
-
-在继续深入讨论约束之前，首先看一个特殊的constraint：**any**，表示类型参数允许是任何类型。any约束下各类型（T）允许的操作有：
-
-- 申明对应类型的变量
-- 给此类型变量重新赋一个相同类型的值
-- 将此类型变量传给其他函数或者作为返回值返回
-- 取此类型变量的地址
-- 强制类型转换为interface{}类型或者赋值给interface{}类型的变量
-- 将类型T强转为类型T(允许但是没啥用)
-- 使用类型断言将interface转换为类型T
-- 在type switch中使用此类型作为其中一个case
-- 定义及使用此类型的复合类型（例如切片）
-- 将此类型作为预定义类型的参数，比如new函数
-
-## Constraint
-
+## Summary
+综上：
+- 函数除了普通参数外，可以额外的类型参数，类型参数使用`[]`包围
+- 这个类型参数可以作为普通参数的类型，也可以直接在函数体内使用
+- 每个参数类型都有个约束，就像普通参数都对应一个类型
 

chapter2-constraints.slide

@@ -1,6 +1,27 @@
 # Go generic
-Qinghe
-21 Jan 2022
+
+清和
+2022-03-31
+
+
+## Constraint
+
+
+## Constraint
+
+在继续深入讨论约束之前，首先看一个特殊的constraint：**any**，表示类型参数允许是任何类型。any约束下各类型（T）允许的操作有：
+
+- 申明对应类型的变量
+- 给此类型变量重新赋一个相同类型的值
+- 将此类型变量传给其他函数或者作为返回值返回
+- 取此类型变量的地址
+- 强制类型转换为interface{}类型或者赋值给interface{}类型的变量
+- 将类型T强转为类型T(允许但是没啥用)
+- 使用类型断言将interface转换为类型T
+- 在type switch中使用此类型作为其中一个case
+- 定义及使用此类型的复合类型（例如切片）
+- 将此类型作为预定义函数的参数，比如new函数
+
 
 ## Defining constraints
 constraints的作用：
@@ -103,15 +124,35 @@ interface即可满足上面的需求，因此继续沿用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.
+- 除了两种例外情况（后面会讲），所有的四则运算、大小比较、逻辑运算只允许被用在预定义类型或者底层为预定义类型的自定义类型中。
+- instead of saying which operators a constraint should support, we can say which types a constraint should accept.
+（与其规定一个约束能够使用哪些操作，不如规定一个约束可以接受哪些类型）
 
+这一想法可以通过定义一个约束的类型集来实现。
 
 ## Type sets
 
 ## Type sets
 
-todo
+每种类型都有相关联的类型集：
+- 对于非接口类型T，其对应的类型集为{T}，集合中仅包含类型T自己
+- 对于接口类型，其对应的类型集为所有实现了接口的类型（无限个）
+
+接口内包含元素：
+1. 函数签名
+2. 其他接口
+
+.code codes/interface.go /INTERFACE OMIT/,/INTERFACE OMIT/
+
+
+
+## Type sets
+
+.image type_set.png  400 600
+
+**接口类型的类型集为接口类型内各元素的类型集的交集**
+
+## Constraint elements
 
 ## Constraint elements
 在interface类型中额外定义一些元素作为约束，这些元素包括：
@@ -194,7 +235,7 @@ todo
 
 现在，下面的代码就可以运行了
 
-.code codes/operator.go /OPERATOR MIN OMIT/,/OPERATOR MIN OMIT/
+.code codes/operator.go /OPERATOR MIN VALID OMIT/,/OPERATOR MIN VALID OMIT/
 
 ## Comparable types in constraints
 
@@ -222,13 +263,12 @@ comparable作为一个约束，它也可以被嵌入在其他约束内。
 - 必须有Hash() uintptr方法
 
 
-## Type inference（类型推断）
+## Type inference
 
 ## Type inference
-可以使用约束类型推断来省略一些代码。在实例化泛型函数或类型时，可以省略部分或全部类型参数。当省略的类型参数可以被推断时，如果只指定部分类型实参，
-则这部分类型实参是类型形参的第一个参数。
+在很多情况下，可以使用类型推断来避免显示指定一个或多个类型参数。可以使用**函数参数类型推断**来根据非类型参数的类型来确定类型参数的值。也可以使用**约束类型推断**来根据已知的参数类型确定其他约束的类型参数值。
 
-举例如下：
+当省略的类型参数可以被推断时，如果只指定部分类型实参，则这部分类型实参依次作为类型形参的前面部分参数值。
 
 .code codes/type_inference.go /MAP OMIT/,/MAP OMIT/
 
@@ -330,15 +370,99 @@ comparable作为一个约束，它也可以被嵌入在其他约束内。
 - NewPair(2, 2.5) => `compilation error`
 
 
+## Constraint type inference
+
+## Constraint type inference
+
+约束类型推断允许基于类型参数约束，根据一个类型参数实参推断出另外一个类型参数的值。
 
-## Constraint type inference (约束类型推断)
+约束类型推断有两种适用场景：
+1. 某个类型参数的约束中用到了其他类型参数
+2. 某个类型参数的约束是基于其他类型参数构成的
 
 
+约束类型推断的过程描述起来可能会比较复杂，但是通过几个典型的详细的例子，推断的过程会比较清晰。
 
-## Constraint type inference
 
-约束类型推断可以基于类型参数约束来从一个类型参数中推断另外一个类型参数的值。
+## Element constraint example
+
+例：实现一个函数，将切片内的所有元素都乘以2，返回新的切片。
+
+.code codes/constraint_inference.go /DOUBLE DEFINATION OMIT/,/DOUBLE DEFINATION OMIT/
+
+但是如果我们定义一个命名类型，然后再去调用呢？
+
+
+.code codes/constraint_inference.go /CALL DOUBLE ERROR OMIT/,/CALL DOUBLE ERROR OMIT/
+
+
+## Element constraint example
+引入一个新的类型参数：
+
+.code codes/constraint_inference.go /DOUBLE DEFINED OMIT/,/DOUBLE DEFINED OMIT/
+
+通过显式指定类型参数，可以得到想要的返回值类型：
+
+.code codes/constraint_inference.go /CALL DOUBLE OMIT/,/CALL DOUBLE OMIT/
+
+
+## Element constraint example
+
+那么这个函数调用是否可以简化为以下形式呢？
+
+
+.code codes/constraint_inference.go /CALL DOUBLE INFERENCE OMIT/,/CALL DOUBLE INFERENCE OMIT/
+
+答案是：**可以的**
+
+虽然是用函数参数类型推断无法完全推断出来，因为类型参数E没有入参与之进行归并，但是函数参数类型推断和约束类型推断结合起来，就可以了。
+
+1. 应用函数类型推断，可以得到{ S -> MySlice}
+2. 应用约束类型推断，归并[]E与MySlice，得到 {S -> MySlice, E -> int}
+3. 完成
+
+可以推断出完整调用：
+
+.code codes/constraint_inference.go /CALL DOUBLE INFERENCE WHOLE OMIT/,/CALL DOUBLE INFERENCE WHOLE OMIT/
+
+
+
+## Pointer method example
+
+再看另外一个例子：
+
+.code codes/constraint_inference.go /POINTER METHOD OMIT/,/POINTER METHOD OMIT/
+
+## Pointer method example
+
+调用示例：
+
+.play -edit -numbers codes/constraint_inference2.go /POINTER METHOD CALL OMIT/,/POINTER METHOD CALL OMIT/
+
+
+类型`Settable`并没有方法`Set(string)`，类型`*Settable`才有。
+
+`*Settable`类型零值为nil，调用Set方法会造成panic。
+
+
+## Pointer method example
+
+我们可以将两种类型都传：
+
+.code codes/constraint_inference3.go /SETTER2 OMIT/,/SETTER2 OMIT/
+
+调用 ：
+
+.play codes/constraint_inference3.go /SETTER2 CALL OMIT/,/SETTER2 CALL OMIT/
+
+## Pointer method example
+
+前面那样调用看起来会比较奇怪，因为需要重复传`Settable`参数，不过可以通过约束类型推断来减少重复工作。
 
-略
+.code codes/constraint_inference3.go /SETTER3 CALL OMIT/,/SETTER3 CALL OMIT/
 
+类型推断过程：
 
+1. {T -> Settable}
+2. {T -> Settable, PT -> *T}
+3. {T -> Settable, PT -> *Settable}

chapter3-others-about-generics.slide

@@ -1,7 +1,8 @@
 
 # More on type sets
-Qinghe
-21 Jan 2022
+
+清和
+2022-03-31
 
 
 ## Both elements and methods in constraints

codes/constraint_inference.go

@@ -0,0 +1,83 @@
+package main 
+
+
+// DOUBLE DEFINATION OMIT
+// Double returns a new slice that contains all the elements of s, doubled.
+func Double[E constraints.Integer](s []E) []E {
+	r := make([]E, len(s))
+	for i, v := range s {
+		r[i] = v + v
+	}
+	return r
+}
+
+var s1 = Double[int]([]int{1,2,3}) // s1 is an int slice with value {2,4,6}
+
+// DOUBLE DEFINATION OMIT
+
+
+// CALL DOUBLE ERROR OMIT
+// MySlice is a slice of ints.
+type MySlice []int
+
+// The type of V1 will be []int, not MySlice.
+// Here we are using function argument type inference,
+// but not constraint type inference.
+var V1 = Double(MySlice{1})
+
+// CALL DOUBLE ERROR OMIT
+
+
+// DOUBLE DEFINED OMIT
+// DoubleDefined returns a new slice that contains the elements of s,
+// doubled, and also has the same type as s.
+func DoubleDefined[S ~[]E, E constraints.Integer](s S) S {
+	// Note that here we pass S to make, where above we passed []E.
+	r := make(S, len(s))
+	for i, v := range s {
+		r[i] = v + v
+	}
+	return r
+}
+// DOUBLE DEFINED OMIT
+
+
+// CALL DOUBLE OMIT
+// The type of V2 will be MySlice.
+var V2 = DoubleDefined[MySlice, int](MySlice{1})
+
+// CALL DOUBLE OMIT
+
+
+// CALL DOUBLE INFERENCE OMIT
+var V3 = DoubleDefined(MySlice{1})
+// CALL DOUBLE INFERENCE OMIT
+
+// CALL DOUBLE INFERENCE WHOLE OMIT
+var V3 = DoubleDefined[MySlice,int](MySlice{1})
+// CALL DOUBLE INFERENCE WHOLE OMIT
+
+
+// POINTER METHOD OMIT
+// Setter is a type constraint that requires that the type
+// implement a Set method that sets the value from a string.
+type Setter interface {
+	Set(string)
+}
+
+// FromStrings takes a slice of strings and returns a slice of T,
+// calling the Set method to set each returned value.
+//
+// Note that because T is only used for a result parameter,
+// function argument type inference does not work when calling
+// this function.
+func FromStrings[T Setter](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		result[i].Set(v)
+	}
+	return result
+}
+// POINTER METHOD OMIT
+
+

codes/constraint_inference2.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"strconv"
+)
+
+// Setter is a type constraint that requires that the type
+// implement a Set method that sets the value from a string.
+type Setter interface {
+    Set(string)
+}
+
+// FromStrings takes a slice of strings and returns a slice of T,
+// calling the Set method to set each returned value.
+//
+// Note that because T is only used for a result parameter,
+// function argument type inference does not work when calling
+// this function.
+func FromStrings[T Setter](s []string) []T {
+    result := make([]T, len(s))
+    for i, v := range s {
+        result[i].Set(v)
+    }
+    return result
+}
+
+// POINTER METHOD CALL OMIT
+// Settable is an integer type that can be set from a string.
+type Settable int
+
+// Set sets the value of *p from a string.
+func (p *Settable) Set(s string) {
+	i, _ := strconv.Atoi(s) // real code should not ignore the error
+	*p = Settable(i)
+}
+
+func main() {
+	// INVALID
+	nums := FromStrings[Settable]([]string{"1", "2"})
+	_ = nums
+	// Here we want nums to be []Settable{1, 2}.
+	// ...
+}
+// POINTER METHOD CALL OMIT

codes/constraint_inference3.go

@@ -0,0 +1,52 @@
+package main 
+
+import (
+	"fmt"
+	"strconv"
+)
+
+
+type Settable int
+
+func (p *Settable) Set(s string) {
+	i, _ := strconv.Atoi(s) // real code should not ignore the error
+	*p = Settable(i)
+}
+
+// SETTER2 OMIT
+type Setter2[B any] interface {
+	Set(string)
+	*B // non-interface type constraint element
+}
+
+func FromStrings2[T any, PT Setter2[T]](s []string) []T {
+	result := make([]T, len(s))
+	for i, v := range s {
+		// The type of &result[i] is *T which is in the type set
+		// of Setter2, so we can convert it to PT.
+		p := PT(&result[i]) 
+		p.Set(v) // PT has a Set method.
+	}
+	return result
+}
+// SETTER2 OMIT
+
+
+func main(){
+// FromStrings2 takes two type parameters.
+	// The second parameter must be a pointer to the first.
+	// Settable is as above.
+// SETTER2 CALL OMIT
+	nums := FromStrings2[Settable, *Settable]([]string{"1", "2"})
+	// Now nums is []Settable{1, 2}.
+	fmt.Println(nums)
+// SETTER2 CALL OMIT
+
+
+/**
+// SETTER3 CALL OMIT
+nums := FromStrings2[Settable]([]string{"1", "2"})
+// SETTER3 CALL OMIT
+*/
+
+}

codes/interface.go

@@ -0,0 +1,12 @@
+package main
+
+
+
+// INTERFACE OMIT
+
+type ReadWriteCloser interface{
+	ReadWriter 
+	Close() error
+}
+
+// INTERFACE OMIT

codes/operator.go

@@ -39,4 +39,18 @@ func Min[T Ordered](s []T) T {
 	return r
 }
 
-// OPERATOR MIN OMIT
+// OPERATOR MIN OMIT
+
+
+// OPERATOR MIN VALID OMIT
+func Min[T Ordered](s []T) T {
+	r := s[0] // assume that s is not empty
+	for _, v := range s {
+		if v < r { // VALID!
+			r = v
+		}
+	}
+	return r
+}
+
+// OPERATOR MIN VALID OMIT