Go1.18新特性之泛型使用三步曲(小结)

func Max(s []int) int {
	if len(s) == 0 {
		return 0
	}
	
	max := s[0]
	for _, v := range s[1:] {
		if v > max {
			max = v
		}
	}
	
	return max
}

m1 := Max([]int{4, -8, 15})

func MaxFloat(s []float) float {
	//...
}

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

func main() {
	m1 := Max[int]([]int{4, -8, 15})
	m2 := Max[float64]([]float64{4.1, -8.1, 15.1})
	
	fmt.Println(m1, m2)
}

// 定义泛型函数
func Max[T constraints.Ordered](s []T) T {
	var zero T
	if len(s) == 0 {
		return zero
	}
	var max T
	max = s[0]
	for _, v := range s[1:] {
		max = v
		if v > max {
			max = v
		}
	}
	
	return max
}

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
        return nil, errors.New("no values given")
    }
	
    switch first := s[0].(type) {
        case int:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(int)
                if v > max {
                    max = v
                }
            }
            return max, nil
		
        case float64:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(float64)
                if v > max {
                    max = v
                }
            } 
            return max, nil
		
         default:
             return nil, fmt.Errorf("unsupported element type of given slice: %T", first)
    }
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
	return nil, errors.New("no values given")
    }
	
    first := reflect.ValueOf(s[0])
	
    if first.Type().Name() == "int"  {
        max := first.Int()
        for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "int" {
                intV := v.Int()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }
	
    if first.Type().Name() == "float64" {
        max := first.Float()
	for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "float64" {
                intV := v.Float()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }
	
    return nil, fmt.Errorf("unsupported element type of given slice: %T", s[0])
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

type ComparableSlice interface {
    // 返回切片的元素个数.
    Len() int
    // 比较索引i的元素值是否比索引j的元素值要小
    Less(i, j int) bool
    // 返回索引i位置的元素
    Elem(i int) interface{}
}

func Max(s ComparableSlice) (interface{}, error) {
    if s.Len() == 0 {
        return nil, errors.New("no values given")
    }
	
    max := s.Elem(0)
    for i := 1; i < s.Len(); i++ {
        if s.Less(i-1, i) {
            max = s.Elem(i)
        }
    }
	
    return max, nil
}

type ComparableIntSlice []int

func (s ComparableIntSlice) Len() int { return len(s) }
func (s ComparableIntSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableIntSlice) Elem(i int) interface{} { return s[i] }

type ComparableFloat64Slice []float64

func (s ComparableFloat64Slice) Len() int { return len(s) }
func (s ComparableFloat64Slice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableFloat64Slice) Elem(i int) interface{} {return s[i]}

// Usage
m1, err1 := Max(ComparableIntSlice([]int{4, -8, 15}))
m2, err2 := Max(ComparableFloat64Slice([]float64{4.1, -8.1, 15.1}))

func Max[T constraints.Ordered](s []T) T {
    var zero T
    if len(s) == 0 {
	return zero
    }
    
    var max T
    max = s[0]
    for _, v := range s[1:] {
	max = v
	if v > max {
            max = v
	}
    }
	
    return max
}

// 自定义类型约束接口StringableFloat
type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}

// MyFloat 是满足StringableFloat类型约束的float类型。
type MyFloat float64 

// 实现类型约束中的String方法
func (m MyFloat) String() string {
    return fmt.Sprintf("%e", m)
}

//泛型函数，对类型参数T使用了StringableFloat约束
func StringifyFloat[T StringableFloat](f T) string {
    return f.String()
}
// Usage
var f MyFloat = 48151623.42

//使用MyFloat类型对T进行实例化
s := StringifyFloat[MyFloat](f)

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    r1 := FirstElem1[[]string, string]([]string{"Go", "rocks"})
    r2 := FirstElem1[[]int, int]([]int{1, 2})

    fmt.Println(r1, r2)
}

// 定义类型约束，并引入类型参数E
type SliceConstraint[E any] interface {
    ~[]E
}

// 泛型函数
func FirstElem1[S SliceConstraint[E], E any](s S) E {
	return s[0]
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    s := []string{"Go", "rocks"}
    r1 := FirstElem1[[]string, string](s)
    r2 := FirstElem2[[]string, string](s)
    r3 := FirstElem3[[]string, string](s)

    fmt.Println(r1, r2, r3)
}

type SliceConstraint[E any] interface {
    ~[]E
}

func FirstElem1[S SliceConstraint[E], E any](s S) E {
    return s[0]
}

func FirstElem2[S interface{ ~[]E }, E any](s S) E {
    return s[0]
}

func FirstElem3[S ~[]E, E any](s S) E {
    return s[0]
}

type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}