func?Add(a?int,?b?int)?int?{
????return?a?+?b
}

func?AddFloat32(a?float32,?b?float32)?float32?{
????return?a?+?b
}

func?AddString(a?string,?b?string)?string?{
????return?a?+?b
}

func?Add(a?int,?b?int)?int?{??
????//?變量a,b是函數(shù)的形參???"a?int,?b?int"?這一串被稱為形參列表
????return?a?+?b
}

Add(100,200)?//?調(diào)用函數(shù)時(shí)，傳入的100和200是實(shí)參

//?假設(shè)?T?是類型形參，在定義函數(shù)時(shí)它的類型是不確定的，類似占位符
func?Add(a?T,?b?T)?T?{??
????return?a?+?b
}

//?[T=int]中的?int?是類型實(shí)參，代表著函數(shù)Add()定義中的類型形參?T?全都被?int?替換
Add[T=int](100,?200)??
//?傳入類型實(shí)參int后，Add()函數(shù)的定義可近似看成下面這樣：
func?Add(?a?int,?b?int)?int?{
????return?a?+?b
}

//?另一個(gè)例子：當(dāng)我們想要計(jì)算兩個(gè)字符串之和的時(shí)候，就傳入string類型實(shí)參
Add[T=string]("Hello",?"World")?
//?類型實(shí)參string傳入后，Add()函數(shù)的定義可近似視為如下
func?Add(?a?string,?b?string)?string?{
????return?a?+?b
}

type?IntSlice?[]int

var?a?IntSlice?=?[]int{1,?2,?3}?//?正確
var?b?IntSlice?=?[]float32{1.0,?2.0,?3.0}?//???錯(cuò)誤，因?yàn)镮ntSlice的底層類型是[]int，浮點(diǎn)類型的切片無(wú)法賦值

type?StringSlice?[]string
type?Float32Slie?[]float32
type?Float64Slice?[]float64

type?Slice[T?int|float32|float64?]?[]T

//?這里傳入了類型實(shí)參int，泛型類型Slice[T]被實(shí)例化為具體的類型?Slice[int]
var?a?Slice[int]?=?[]int{1,?2,?3}??
fmt.Printf("Type?Name:?%T",a)??//輸出：Type?Name:?Slice[int]

//?傳入類型實(shí)參float32,?將泛型類型Slice[T]實(shí)例化為具體的類型?Slice[string]
var?b?Slice[float32]?=?[]float32{1.0,?2.0,?3.0}?
fmt.Printf("Type?Name:?%T",b)??//輸出：Type?Name:?Slice[float32]

//???錯(cuò)誤。因?yàn)樽兞縜的類型為Slice[int]，b的類型為Slice[float32]，兩者類型不同
a?=?b??

//???錯(cuò)誤。string不在類型約束?int|float32|float64?中，不能用來(lái)實(shí)例化泛型類型
var?c?Slice[string]?=?[]string{"Hello",?"World"}?

//???錯(cuò)誤。Slice[T]是泛型類型，不可直接使用必須實(shí)例化為具體的類型
var?x?Slice[T]?=?[]int{1,?2,?3}?

type?Slice[int]?[]int?????//?定義了一個(gè)普通的類型?Slice[int]?，它的底層類型是?[]int

//?MyMap類型定義了兩個(gè)類型形參?KEY?和?VALUE。分別為兩個(gè)形參指定了不同的類型約束
//?這個(gè)泛型類型的名字叫：?MyMap[KEY,?VALUE]
type?MyMap[KEY?int?|?string,?VALUE?float32?|?float64]?map[KEY]VALUE??

//?用類型實(shí)參?string?和?flaot64?替換了類型形參?KEY?、?VALUE，泛型類型被實(shí)例化為具體的類型：MyMap[string,?float64]
var?a?MyMap[string,?float64]?=?map[string]float64{
????"jack_score":?9.6,
????"bob_score":??8.4,
}

//?一個(gè)泛型類型的結(jié)構(gòu)體。可用?int?或?sring?類型實(shí)例化
type?MyStruct[T?int?|?string]?struct?{??
????Name?string
????Data?T
}

//?一個(gè)泛型接口(關(guān)于泛型接口在后半部分會(huì)詳細(xì)講解）
type?IPrintData[T?int?|?float32?|?string]?interface?{
????Print(data?T)
}

//?一個(gè)泛型通道，可用類型實(shí)參?int?或?string?實(shí)例化
type?MyChan[T?int?|?string]?chan?T

type?WowStruct[T?int?|?float32,?S?[]T]?struct?{
????Data?????S
????MaxValue?T
????MinValue?T
}

var?ws?WowStruct[int,?[]int]
//?泛型類型?WowStuct[T,?S]?被實(shí)例化后的類型名稱就叫?WowStruct[int,?[]int]

//?一個(gè)存儲(chǔ)int類型切片，以及切片中最大、最小值的結(jié)構(gòu)體
type?WowStruct[int,?[]int]?struct?{
????Data?????[]int
????MaxValue?int
????MinValue?int
}

//?錯(cuò)誤。S的定義是[]T，這里T傳入了實(shí)參int,?所以S的實(shí)參應(yīng)當(dāng)為?[]int?而不能是?[]float32
ws?:=?WowStruct[int,?[]float32]{
????????Data:?????[]float32{1.0,?2.0,?3.0},
????????MaxValue:?3,
????????MinValue:?1,
????}

//?錯(cuò)誤，類型形參不能單獨(dú)使用
type?CommonType[T?int|string|float32]?T

//??錯(cuò)誤。T?*int會(huì)被編譯器誤認(rèn)為是表達(dá)式?T乘以int，而不是int指針
type?NewType[T?*int]?[]T
//?上面代碼再編譯器眼中：它認(rèn)為你要定義一個(gè)存放切片的數(shù)組，數(shù)組長(zhǎng)度由?T?乘以?int?計(jì)算得到
type?NewType?[T?*?int][]T?

//??錯(cuò)誤。和上面一樣，這里不光*被會(huì)認(rèn)為是乘號(hào)，|?還會(huì)被認(rèn)為是按位或操作
type?NewType2[T?*int|*float64]?[]T?

//??錯(cuò)誤
type?NewType2?[T?(int)]?[]T?

type?NewType[T?interface{*int}]?[]T
type?NewType2[T?interface{*int|*float64}]?[]T?

//?如果類型約束中只有一個(gè)類型，可以添加個(gè)逗號(hào)消除歧義
type?NewType3[T?*int,]?[]T

//??錯(cuò)誤。如果類型約束不止一個(gè)類型，加逗號(hào)是不行的
type?NewType4[T?*int|*float32,]?[]T?

type?Wow[T?int?|?string]?int

var?a?Wow[int]?=?123?????//?編譯正確
var?b?Wow[string]?=?123??//?編譯正確
var?c?Wow[string]?=?"hello"?//?編譯錯(cuò)誤，因?yàn)?hello"不能賦值給底層類型int

//?先定義個(gè)泛型類型?Slice[T]
type?Slice[T?int|string|float32|float64]?[]T

//???錯(cuò)誤。泛型類型Slice[T]的類型約束中不包含uint,?uint8
type?UintSlice[T?uint|uint8]?Slice[T]??

//???正確?；诜盒皖愋蚐lice[T]定義了新的泛型類型?FloatSlice[T]?。FloatSlice[T]只接受float32和float64兩種類型
type?FloatSlice[T?float32|float64]?Slice[T]?

//???正確。基于泛型類型Slice[T]定義的新泛型類型?IntAndStringSlice[T]
type?IntAndStringSlice[T?int|string]?Slice[T]??
//???正確?基于IntAndStringSlice[T]套娃定義出的新泛型類型
type?IntSlice[T?int]?IntAndStringSlice[T]?

//?在map中套一個(gè)泛型類型Slice[T]
type?WowMap[T?int|string]?map[string]Slice[T]
//?在map中套Slice[T]的另一種寫法
type?WowMap2[T?Slice[int]?|?Slice[string]]?map[string]T

type?WowStruct[T?int|string]?struct?{
????Name?string
????Data?[]T
}

type?WowStruct2[T?[]int|[]string]?struct?{
????Name?string
????Data?T
}

type?WowStruct3[T?int?|?string]?struct?{
????Data?????[]T
????MaxValue?T
????MinValue?T
}

testCase?:=?struct?{
????????caseName?string
????????got??????int
????????want?????int
????}{
????????caseName:?"test?OK",
????????got:??????100,
????????want:?????100,
????}
??
//那么匿名結(jié)構(gòu)體能不能使用泛型呢？答案是不能，下面的用法是錯(cuò)誤的：

testCase?:=?struct[T?int|string]?{
????????caseName?string
????????got??????T
????????want?????T
????}[int]{
????????caseName:?"test?OK",
????????got:??????100,
????????want:?????100,
????}

type?MySlice[T?int?|?float32]?[]T

func?(s?MySlice[T])?Sum()?T?{
????var?sum?T
????for?_,?value?:=?range?s?{
????????sum?+=?value
????}
????return?sum
}

var?s?MySlice[int]?=?[]int{1,?2,?3,?4}
fmt.Println(s.Sum())?//?輸出：10

var?s2?MySlice[float32]?=?[]float32{1.0,?2.0,?3.0,?4.0}
fmt.Println(s2.Sum())?//?輸出：10.0

type?MySlice[int]?[]int?//?實(shí)例化后的類型名叫?MyIntSlice[int]

//?方法中所有類型形參?T?都被替換為類型實(shí)參?int
func?(s?MySlice[int])?Sum()?int?{
????var?sum?int?
????for?_,?value?:=?range?s?{
????????sum?+=?value
????}
????return?sum
}

//?這里類型約束使用了空接口，代表的意思是所有類型都可以用來(lái)實(shí)例化泛型類型?Queue[T]?(關(guān)于接口在后半部分會(huì)詳細(xì)介紹）
type?Queue[T?interface{}]?struct?{
????elements?[]T
}

//?將數(shù)據(jù)放入隊(duì)列尾部
func?(q?*Queue[T])?Put(value?T)?{
????q.elements?=?append(q.elements,?value)
}

//?從隊(duì)列頭部取出并從頭部刪除對(duì)應(yīng)數(shù)據(jù)
func?(q?*Queue[T])?Pop()?(T,?bool)?{
????var?value?T
????if?len(q.elements)?==?0?{
????????return?value,?true
????}

????value?=?q.elements[0]
????q.elements?=?q.elements[1:]
????return?value,?len(q.elements)?==?0
}

//?隊(duì)列大小
func?(q?Queue[T])?Size()?int?{
????return?len(q.elements)
}

var?q1?Queue[int]??//?可存放int類型數(shù)據(jù)的隊(duì)列
q1.Put(1)
q1.Put(2)
q1.Put(3)
q1.Pop()?//?1
q1.Pop()?//?2
q1.Pop()?//?3

var?q2?Queue[string]??//?可存放string類型數(shù)據(jù)的隊(duì)列
q2.Put("A")
q2.Put("B")
q2.Put("C")
q2.Pop()?//?"A"
q2.Pop()?//?"B"
q2.Pop()?//?"C"

var?q3?Queue[struct{Name?string}]?
var?q4?Queue[[]int]?//?可存放[]int切片的隊(duì)列
var?q5?Queue[chan?int]?//?可存放int通道的隊(duì)列
var?q6?Queue[io.Reader]?//?可存放接口的隊(duì)列
//?......

var?i?interface{}?=?123
i.(int)?//?類型斷言

//?type?switch
switch?i.(type)?{
????case?int:
????????//?do?something
????case?string:
????????//?do?something
????default:
????????//?do?something
????}
}

func?(q?*Queue[T])?Put(value?T)?{
????value.(int)?//?錯(cuò)誤。泛型類型定義的變量不能使用類型斷言

????//?錯(cuò)誤。不允許使用type?switch?來(lái)判斷?value?的具體類型
????switch?value.(type)?{
????case?int:
????????//?do?something
????case?string:
????????//?do?something
????default:
????????//?do?something
????}
????
????//?...
}

func?(receiver?Queue[T])?Put(value?T)?{
????//?Printf()?可輸出變量value的類型(底層就是通過(guò)反射實(shí)現(xiàn)的)
????fmt.Printf("%T",?value)?

????//?通過(guò)反射可以動(dòng)態(tài)獲得變量value的類型從而分情況處理
????v?:=?reflect.ValueOf(value)

????switch?v.Kind()?{
????case?reflect.Int:
????????//?do?something
????case?reflect.String:
????????//?do?something
????}

????//?...
}

func?Add(a?int,?b?int)?int?{
????return?a?+?b
}

func?Add[T?int?|?float32?|?float64](a?T,?b?T)?T?{
????return?a?+?b
}

Add[int](1,2)?//?傳入類型實(shí)參int，計(jì)算結(jié)果為?3
Add[float32](1.0,?2.0)?//?傳入類型實(shí)參float32,?計(jì)算結(jié)果為?3.0

Add[string]("hello",?"world")?//?錯(cuò)誤。因?yàn)榉盒秃瘮?shù)Add的類型約束中并不包含string
或許你會(huì)覺(jué)得這樣每次都要手動(dòng)指定類型實(shí)參太不方便了。所以Go還支持類型實(shí)參的自動(dòng)推導(dǎo)：

Add(1,?2)??//?1，2是int類型，編譯請(qǐng)自動(dòng)推導(dǎo)出類型實(shí)參T是int
Add(1.0,?2.0)?//?1.0,?2.0?是浮點(diǎn)，編譯請(qǐng)自動(dòng)推導(dǎo)出類型實(shí)參T是float32

fn?:=?func(a,?b?int)?int?{
????return?a?+?b?
}??//?定義了一個(gè)匿名函數(shù)并賦值給?fn?

fmt.Println(fn(1,?2))?//?輸出:?3

//?錯(cuò)誤，匿名函數(shù)不能自己定義類型實(shí)參
fnGeneric?:=?func[T?int?|?float32](a,?b?T)?T?{
????????return?a?+?b
}?

fmt.Println(fnGeneric(1,?2))

func?MyFunc[T?int?|?float32?|?float64](a,?b?T)?{

????//?匿名函數(shù)可使用已經(jīng)定義好的類型形參
????fn2?:=?func(i?T,?j?T)?T?{
????????return?i*2?-?j*2
????}

????fn2(a,?b)
}

type?A?struct?{
}

//?不支持泛型方法
func?(receiver?A)?Add[T?int?|?float32?|?float64](a?T,?b?T)?T?{
????return?a?+?b
}
//但是因?yàn)閞eceiver支持泛型，?所以如果想在方法中使用泛型的話，目前唯一的辦法就是曲線救國(guó)，迂回地通過(guò)receiver使用類型形參：

type?A[T?int?|?float32?|?float64]?struct?{
}

//?方法可以使用類型定義中的形參?T?
func?(receiver?A[T])?Add(a?T,?b?T)?T?{
????return?a?+?b
}

//?用法：
var?a?A[int]
a.Add(1,?2)

var?aa?A[float32]
aa.Add(1.0,?2.0)

//?一個(gè)可以容納所有int,uint以及浮點(diǎn)類型的泛型切片
type?Slice[T?int?|?int8?|?int16?|?int32?|?int64?|?uint?|?uint8?|?uint16?|?uint32?|?uint64?|?float32?|?float64]?[]T

type?IntUintFloat?interface?{
????int?|?int8?|?int16?|?int32?|?int64?|?uint?|?uint8?|?uint16?|?uint32?|?uint64?|?float32?|?float64
}

type?Slice[T?IntUintFloat]?[]T

type?Int?interface?{
????int?|?int8?|?int16?|?int32?|?int64
}

type?Uint?interface?{
????uint?|?uint8?|?uint16?|?uint32
}

type?Float?interface?{
????float32?|?float64
}

type?Slice[T?Int?|?Uint?|?Float]?[]T??//?使用?'|'?將多個(gè)接口類型組合

type?SliceElement?interface?{
????Int?|?Uint?|?Float?|?string?//?組合了三個(gè)接口類型并額外增加了一個(gè)?string?類型
}

type?Slice[T?SliceElement]?[]T?

var?s1?Slice[int]?//?正確?

type?MyInt?int
var?s2?Slice[MyInt]?//???錯(cuò)誤。MyInt類型底層類型是int但并不是int類型，不符合?Slice[T]?的類型約束

type?Int?interface?{
????~int?|?~int8?|?~int16?|?~int32?|?~int64
}

type?Uint?interface?{
????~uint?|?~uint8?|?~uint16?|?~uint32
}
type?Float?interface?{
????~float32?|?~float64
}

type?Slice[T?Int?|?Uint?|?Float]?[]T?

var?s?Slice[int]?//?正確

type?MyInt?int
var?s2?Slice[MyInt]??//?MyInt底層類型是int，所以可以用于實(shí)例化

type?MyMyInt?MyInt
var?s3?Slice[MyMyInt]??//?正確。MyMyInt?雖然基于?MyInt?，但底層類型也是int，所以也能用于實(shí)例化

type?MyFloat32?float32??//?正確
var?s4?Slice[MyFloat32]

type?MyInt?int

type?_?interface?{
????~[]byte??//?正確
????~MyInt???//?錯(cuò)誤，~后的類型必須為基本類型
????~error???//?錯(cuò)誤，~后的類型不能為接口
}

type?ReadWriter?interface?{
????Read(p?[]byte)?(n?int,?err?error)
????Write(p?[]byte)?(n?int,?err?error)
}

type?Float?interface?{
????~float32?|?~float64
}

type?Slice[T?Float]?[]T?

var?s?Slice[int]??????//?int?屬于類型集?Float?，所以int可以作為類型實(shí)參
var?s?Slice[chan?int]?//?chan?int?類型不在類型集?Float?中，所以錯(cuò)誤

type?Uint?interface?{??//?類型集?Uint?是?~uint?和?~uint8?等類型的并集
????~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint64
}

type?AllInt?interface?{
????~int?|?~int8?|?~int16?|?~int32?|?~int64?|?~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint32
}

type?Uint?interface?{
????~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint64
}

type?A?interface?{?//?接口A代表的類型集是?AllInt?和?Uint?的交集
????AllInt
????Uint
}

type?B?interface?{?//?接口B代表的類型集是?AllInt?和?~int?的交集
????AllInt
????~int
}

type?C?interface?{
????~int
????int
}

type?Bad?interface?{
????int
????float32?
}?//?類型?int?和?float32?沒(méi)有相交的類型，所以接口?Bad?代表的類型集為空

//?空接口代表所有類型的集合。寫入類型約束意味著所有類型都可拿來(lái)做類型實(shí)參
type?Slice[T?interface{}]?[]T

var?s1?Slice[int]????//?正確
var?s2?Slice[map[string]string]??//?正確
var?s3?Slice[chan?int]??//?正確
var?s4?Slice[interface{}]??//?正確

type?Slice[T?any]?[]T?//?代碼等價(jià)于?type?Slice[T?interface{}]?[]T

//?any?is?an?alias?for?interface{}?and?is?equivalent?to?interface{}?in?all?ways.
type?any?=?interface{}?

var?s?[]any?//?等價(jià)于?var?s?[]interface{}
var?m?map[string]any?//?等價(jià)于?var?m?map[string]interface{}

func?MyPrint(value?any){
????fmt.Println(value)
}

gofmt?-w?-r?'interface{}?->?any'?./...

//?錯(cuò)誤。因?yàn)?map?中鍵的類型必須是可進(jìn)行?!=?和?==?比較的類型
type?MyMap[KEY?any,?VALUE?any]?map[KEY]VALUE?

type?MyMap[KEY?comparable,?VALUE?any]?map[KEY]VALUE?//?正確

type?OhMyStruct?struct?{
????a?int
}

var?a,?b?OhMyStruct

a?==?b?//?正確。結(jié)構(gòu)體可使用?==?進(jìn)行比較
a?!=?b?//?正確

a?>?b?//?錯(cuò)誤。結(jié)構(gòu)體不可比大小

//?Ordered?代表所有可比大小排序的類型
type?Ordered?interface?{
????Integer?|?Float?|?~string
}

type?Integer?interface?{
????Signed?|?Unsigned
}

type?Signed?interface?{
????~int?|?~int8?|?~int16?|?~int32?|?~int64
}

type?Unsigned?interface?{
????~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint64?|?~uintptr
}

type?Float?interface?{
????~float32?|?~float64
}

type?ReadWriter?interface?{
????~string?|?~[]rune

????Read(p?[]byte)?(n?int,?err?error)
????Write(p?[]byte)?(n?int,?err?error)
}

//?類型?StringReadWriter?實(shí)現(xiàn)了接口?Readwriter
type?StringReadWriter?string?

func?(s?StringReadWriter)?Read(p?[]byte)?(n?int,?err?error)?{
????//?...
}

func?(s?StringReadWriter)?Write(p?[]byte)?(n?int,?err?error)?{
?//?...
}

//??類型BytesReadWriter?沒(méi)有實(shí)現(xiàn)接口?Readwriter
type?BytesReadWriter?[]byte?

func?(s?BytesReadWriter)?Read(p?[]byte)?(n?int,?err?error)?{
?...
}

func?(s?BytesReadWriter)?Write(p?[]byte)?(n?int,?err?error)?{
?...
}

type?MyError?interface?{?//?接口中只有方法，所以是基本接口
????Error()?string
}

//?用法和?Go1.18之前保持一致
var?err?MyError?=?fmt.Errorf("hello?world")

//?io.Reader?和?io.Writer?都是基本接口，也可以用在類型約束中
type?MySlice[T?io.Reader?|?io.Writer]??[]Slice

type?Uint?interface?{?//?接口?Uint?中有類型，所以是一般接口
????~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint64
}

type?ReadWriter?interface?{??//?ReadWriter?接口既有方法也有類型，所以是一般接口
????~string?|?~[]rune

????Read(p?[]byte)?(n?int,?err?error)
????Write(p?[]byte)?(n?int,?err?error)
}

type?Uint?interface?{
????~uint?|?~uint8?|?~uint16?|?~uint32?|?~uint64
}

var?uintInf?Uint?//?錯(cuò)誤。Uint是一般接口，只能用于類型約束，不得用于變量定義

type?DataProcessor[T?any]?interface?{
????Process(oriData?T)?(newData?T)
????Save(data?T)?error
}

type?DataProcessor2[T?any]?interface?{
????int?|?~struct{?Data?interface{}?}

????Process(data?T)?(newData?T)
????Save(data?T)?error
}

DataProcessor[string]

//?實(shí)例化之后的接口定義相當(dāng)于如下所示：
type?DataProcessor[string]?interface?{
????Process(oriData?string)?(newData?string)
????Save(data?string)?error
}

type?CSVProcessor?struct?{
}

//?注意，方法中?oriData?等的類型是?string
func?(c?CSVProcessor)?Process(oriData?string)?(newData?string)?{
????....
}

func?(c?CSVProcessor)?Save(oriData?string)?error?{
????...
}

//?CSVProcessor實(shí)現(xiàn)了接口?DataProcessor[string]?，所以可賦值
var?processor?DataProcessor[string]?=?CSVProcessor{}??
processor.Process("name,age\nbob,12\njack,30")
processor.Save("name,age\nbob,13\njack,31")

//?錯(cuò)誤。CSVProcessor沒(méi)有實(shí)現(xiàn)接口?DataProcessor[int]
var?processor2?DataProcessor[int]?=?CSVProcessor{}

DataProcessor2[string]

//?實(shí)例化后的接口定義可視為
type?DataProcessor2[T?string]?interface?{
????int?|?~struct{?Data?interface{}?}

????Process(data?string)?(newData?string)
????Save(data?string)?error
}

//?XMLProcessor?雖然實(shí)現(xiàn)了接口?DataProcessor2[string]?的兩個(gè)方法，但是因?yàn)樗牡讓宇愋褪?[]byte，所以依舊是未實(shí)現(xiàn)?DataProcessor2[string]
type?XMLProcessor?[]byte

func?(c?XMLProcessor)?Process(oriData?string)?(newData?string)?{

}

func?(c?XMLProcessor)?Save(oriData?string)?error?{

}

//?JsonProcessor?實(shí)現(xiàn)了接口?DataProcessor2[string]?的兩個(gè)方法，同時(shí)底層類型是?struct{?Data?interface{}?}。所以實(shí)現(xiàn)了接口?DataProcessor2[string]
type?JsonProcessor?struct?{
????Data?interface{}
}

func?(c?JsonProcessor)?Process(oriData?string)?(newData?string)?{

}

func?(c?JsonProcessor)?Save(oriData?string)?error?{

}

//?錯(cuò)誤。DataProcessor2[string]是一般接口不能用于創(chuàng)建變量
var?processor?DataProcessor2[string]

//?正確，實(shí)例化之后的?DataProcessor2[string]?可用于泛型的類型約束
type?ProcessorList[T?DataProcessor2[string]]?[]T

//?正確，接口可以并入其他接口
type?StringProcessor?interface?{
????DataProcessor2[string]

????PrintString()
}

//?錯(cuò)誤，帶方法的一般接口不能作為類型并集的成員(參考6.5?接口定義的種種限制規(guī)則
type?StringProcessor?interface?{
????DataProcessor2[string]?|?DataProcessor2[[]byte]

????PrintString()
}

type?MyInt?int

//?錯(cuò)誤，MyInt的底層類型是int,和?~int?有相交的部分
type?_?interface?{
????~int?|?MyInt
}

type?MyInt?int

type?_?interface?{
????~int?|?interface{?MyInt?}??//?正確
}

type?_?interface?{
????interface{?~int?}?|?MyInt?//?也正確
}

type?_?interface?{
????interface{?~int?}?|?interface{?MyInt?}??//?也正確
}

type?MyInf[T?~int?|?~string]?interface?{
????~float32?|?T??//?錯(cuò)誤。T是類型形參
}

type?MyInf2[T?~int?|?~string]?interface?{
????T??//?錯(cuò)誤
}

type?Bad?interface?{
????Bad?//?錯(cuò)誤，接口不能直接并入自己
}

type?Bad2?interface?{
????Bad1
}
type?Bad1?interface?{
????Bad2?//?錯(cuò)誤，接口Bad1通過(guò)Bad2間接并入了自己
}

type?Bad3?interface?{
????~int?|?~string?|?Bad3?//?錯(cuò)誤，通過(guò)類型的并集并入了自己
}

type?OK?interface?{
????comparable?//?正確。只有一個(gè)類型的時(shí)候可以使用?comparable
}

type?Bad1?interface?{
????[]int?|?comparable?//?錯(cuò)誤，類型并集不能直接并入?comparable?接口
}

type?CmpInf?interface?{
????comparable
}
type?Bad2?interface?{
????chan?int?|?CmpInf??//?錯(cuò)誤，類型并集通過(guò)?CmpInf?間接并入了comparable
}
type?Bad3?interface?{
????chan?int?|?interface{comparable}??//?理所當(dāng)然，這樣也是不行的
}

type?_?interface?{
????~int?|?~string?|?error?//?錯(cuò)誤，error是帶方法的接口(一般接口)?不能寫入并集中
}

type?DataProcessor[T?any]?interface?{
????~string?|?~[]byte

????Process(data?T)?(newData?T)
????Save(data?T)?error
}

//?錯(cuò)誤，實(shí)例化之后的?DataProcessor[string]?是帶方法的一般接口，不能寫入類型并集
type?_?interface?{
????~int?|?~string?|?DataProcessor[string]?
}

type?Bad[T?any]?interface?{
????~int?|?~string?|?DataProcessor[T]??//?也不行
}