// 聯(lián)合類型約束：限定數(shù)值類型
type Numeric interface {
  int | float32 | float64
}
// 行為約束：要求實(shí)現(xiàn)String()方法
type Stringer interface {
  String() string
}
// 聯(lián)合+行為約束
type NumericStringer interface {
  int | float64
  String() string
}

package main
import "fmt"
type Numeric interface { int | float32 | float64 }
func Sum[T Numeric](a, b T) T { return a + b }
func main() {
  fmt.Println(Sum(10,20))        // T=int → 30
  fmt.Println(Sum(1.5,2.5))      // T=float64 → 4.0
  fmt.Println(Sum[int](100,200)) // 顯式指定 → 300
}

package main
import "fmt"
func RemoveDuplicate[T comparable](slice []T) []T {
  result := make([]T, 0, len(slice))
  tempMap := make(map[T]struct{}, len(slice))
  for _, val := range slice {
    if _, ok := tempMap[val]; !ok {
      tempMap[val] = struct{}{}
      result = append(result, val)
    }
  }
  return result
}
func main() {
  fmt.Println(RemoveDuplicate([]int{1,2,2,3})) // [1 2 3]
  fmt.Println(RemoveDuplicate([]string{"a","b","a"})) // [a b]
}

package main
import ("errors"; "fmt")
type Stack[T any] struct{ elements []T }
func (s *Stack[T]) Push(e T) { s.elements = append(s.elements, e) }
func (s *Stack[T]) Pop() (T, error) {
  if s.IsEmpty() { return *new(T), errors.New("棧為空") }
  topIdx := len(s.elements)-1
  top := s.elements[topIdx]
  s.elements = s.elements[:topIdx]
  return top, nil
}
func (s *Stack[T]) IsEmpty() bool { return len(s.elements) == 0 }
func main() {
  s := &Stack[int]{}
  s.Push(10); s.Push(20)
  top, _ := s.Pop()
  fmt.Println(top) // 20
}

package main
import ("fmt"; "strconv"; "strings")
type Converter[T, V any] interface { Convert(T) (V, error) }
// int轉(zhuǎn)string實(shí)現(xiàn)
type IntToStringConverter struct{}
func (c *IntToStringConverter) Convert(t int) (string, error) {
  return strconv.Itoa(t), nil
}
// string轉(zhuǎn)User實(shí)現(xiàn)
type User struct{ ID int; Name string }
type StringToUserConverter struct{}
func (c *StringToUserConverter) Convert(t string) (User, error) {
  parts := strings.Split(t, ",")
  if len(parts)!=2 { return User{}, fmt.Errorf("格式錯(cuò)誤") }
  id, _ := strconv.Atoi(parts[0])
  return User{ID: id, Name: parts[1]}, nil
}
func main() {
  c1 := &IntToStringConverter{}
  fmt.Println(c1.Convert(100)) // 100 <nil>
}

package main
import "fmt"

// 泛型map合并：將map2合并到map1，key沖突時(shí)map2覆蓋map1
func MergeMap[K comparable, V any](map1, map2 map[K]V) map[K]V {
    result := make(map[K]V, len(map1)+len(map2))
    // 先復(fù)制map1
    for k, v := range map1 {
        result[k] = v
    }
    // 合并map2，覆蓋沖突key
    for k, v := range map2 {
        result[k] = v
    }
    return result
}

// 泛型map遍歷：提取所有value組成切片
func MapValues[K comparable, V any](m map[K]V) []V {
    values := make([]V, 0, len(m))
    for _, v := range m {
        values = append(values, v)
    }
    return values
}

func main() {
    m1 := map[string]int{"a":1, "b":2}
    m2 := map[string]int{"b":3, "c":4}
    // 合并map
    merged := MergeMap(m1, m2)
    fmt.Println("合并后map：", merged) // map[a:1 b:3 c:4]
    // 提取value切片
    values := MapValues(merged)
    fmt.Println("map所有value：", values) // [1 3 4]
}

package main
import ("errors"; "fmt"; "strconv")

// 復(fù)用之前的Converter泛型接口
type Converter[T, V any] interface { Convert(T) (V, error) }

// 嵌套泛型結(jié)構(gòu)體：Stack中存儲(chǔ)轉(zhuǎn)換后的V類型數(shù)據(jù)
type ConvertStack[T, V any] struct {
    stack Stack[V]      // 嵌套泛型結(jié)構(gòu)體Stack
    conv  Converter[T, V] // 嵌套泛型接口Converter
}

// 構(gòu)造函數(shù)
func NewConvertStack[T, V any](conv Converter[T, V]) *ConvertStack[T, V] {
    return &ConvertStack[T, V]{
        stack: Stack[V]{},
        conv:  conv,
    }
}

// 入棧前先轉(zhuǎn)換數(shù)據(jù)
func (cs *ConvertStack[T, V]) PushAndConvert(t T) error {
    v, err := cs.conv.Convert(t)
    if err != nil {
        return err
    }
    cs.stack.Push(v)
    return nil
}

// 出棧（復(fù)用Stack的Pop方法）
func (cs *ConvertStack[T, V]) Pop() (V, error) {
    return cs.stack.Pop()
}

// 復(fù)用之前的Stack泛型結(jié)構(gòu)體
type Stack[V any] struct{ elements []V }
func (s *Stack[V]) Push(e V) { s.elements = append(s.elements, e) }
func (s *Stack[V]) Pop() (V, error) {
    if len(s.elements) == 0 { return *new(V), errors.New("棧為空") }
    topIdx := len(s.elements)-1
    top := s.elements[topIdx]
    s.elements = s.elements[:topIdx]
    return top, nil
}

// 實(shí)現(xiàn)int轉(zhuǎn)string的Converter
type IntToStringConverter struct{}
func (c *IntToStringConverter) Convert(t int) (string, error) {
    return strconv.Itoa(t), nil
}

func main() {
    cs := NewConvertStack[int, string](&IntToStringConverter{})
    cs.PushAndConvert(10)
    cs.PushAndConvert(20)
    val, _ := cs.Pop()
    fmt.Println("出棧值（已轉(zhuǎn)換）：", val) // 20
}

package main
import "fmt"

// 泛型通道處理：從輸入通道讀取數(shù)據(jù)，處理后寫入輸出通道
func ProcessChan[T, V any](inChan <-chan T, outChan chan<- V, process func(T) V) {
    defer close(outChan)
    for t := range inChan {
        v := process(t)
        outChan <- v
    }
}

func main() {
    inChan := make(chan int, 3)
    outChan := make(chan string, 3)

    // 寫入數(shù)據(jù)到輸入通道
    inChan <- 10
    inChan <- 20
    inChan <- 30
    close(inChan)

    // 啟動(dòng)處理協(xié)程：int轉(zhuǎn)string
    go ProcessChan[int, string](inChan, outChan, func(t int) string {
        return fmt.Sprintf("數(shù)值：%d", t)
    })

    // 讀取輸出通道數(shù)據(jù)
    for s := range outChan {
        fmt.Println(s) // 依次輸出：數(shù)值：10、數(shù)值：20、數(shù)值：30
    }
}

package main
import ("fmt"; "time")

// 泛型函數(shù)包裝器：統(tǒng)計(jì)任意函數(shù)的執(zhí)行耗時(shí)
func TimeCost[T any, V any](f func(T) V) func(T) V {
    return func(t T) V {
        start := time.Now()
        res := f(t)
        cost := time.Since(start)
        fmt.Printf("函數(shù)執(zhí)行耗時(shí)：%v\n", cost)
        return res
    }
}

// 測(cè)試函數(shù)1：int轉(zhuǎn)string
func IntToStr(t int) string {
    time.Sleep(100 * time.Millisecond)
    return fmt.Sprintf("%d", t)
}

// 測(cè)試函數(shù)2：計(jì)算切片總和
func SliceSum(t []int) int {
    time.Sleep(50 * time.Millisecond)
    sum := 0
    for _, v := range t {
        sum += v
    }
    return sum
}

func main() {
    // 包裝并調(diào)用IntToStr
    wrappedIntToStr := TimeCost(IntToStr)
    wrappedIntToStr(100) // 輸出：函數(shù)執(zhí)行耗時(shí)：100+ms

    // 包裝并調(diào)用SliceSum
    wrappedSliceSum := TimeCost(SliceSum)
    wrappedSliceSum([]int{1,2,3,4,5}) // 輸出：函數(shù)執(zhí)行耗時(shí)：50+ms
}