理解Golang的泛型

func F[T C](v T) (T,error) {
    ...
}

type S[T C] struct {
	v T
}

type I[T C] interface {
	~int | ~int32 | ~int64
	M(v T) T
}

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

// comparable is an interface that is implemented by all comparable types
// (booleans, numbers, strings, pointers, channels, arrays of comparable types,
// structs whose fields are all comparable types).
// The comparable interface may only be used as a type parameter constraint,
// not as the type of a variable.
type comparable interface{ comparable }

func Equal[T comparable](v1, v2 T) bool {
	return v1 == v2
}

func TestCom(t *testing.T) {
	var a1 interface{} = 1
	var a2 interface{} = 2
	assert.Equal(t, true, Equal(a1, a2)) // interface{} does not implement comparable
}

// A Duration represents the elapsed time between two instants
// as an int64 nanosecond count. The representation limits the
// largest representable duration to approximately 290 years.
type Duration int64

func sumGeneric[T ~int | float32 | ~int64 | float64 | string](ns ...T) (sum T) {
	for _, v := range ns {
		sum += v
	}
	return sum
}

// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
type Ordered interface {
	Integer | Float | ~string
}

type Or[T constraints.Ordered] struct {
	num T
}

func sumInt(ns ...int) (sum int) {
	for _, v := range ns {
		sum += v
	}
	return sum
}
func sumFloat(ns ...float32) (sum float32) {
	for _, v := range ns {
		sum += v
	}
	return sum
}

func GenericSum[T int | float64](elems ...T) (sum T) {
	for _, v := range elems {
		sum += v
	}
	return sum
}

func TestGenericSum(t *testing.T) {
	assert.Equal(t, 5, GenericSum[int](1, 2, 2)) // 显示定义类型为 int
	assert.Equal(t, 5, GenericSum(1.0, 2.0, 2.0))    // 自动推导类型为float64
}

func GenericSum[T ~int | float32 | ~int64 | float64 | string](elems ...T) (sum T) {
	for _, v := range elems {
		sum += v
	}
	return sum
}

// SliceMap 将数组 s 中的数据处理后输入到新数组中并返回
// 这里定义两种类型，表示允许输入一种类型，输出另一种类型
func SliceMap[T, R any](s []T, f func(T) R) []R {
	result := make([]R, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}
func TestSliceMap(t *testing.T) {
	ss := []string{"1", "2", "3"}
	ff := func(input string) int {
		v, _ := strconv.Atoi(input)
		return v
	}
	assert.Equal(t, []int{1, 2, 3}, SliceMap(ss, ff))
}

// Pick 随机选取数组中一个对象返回
// 波浪线表示包含所有基于此类型派生的新类型(即type定义新类型)
func Pick[E ~int64 | string, S []E](s S) (ret E) {
	if len(s) == 0 {
		return ret
	}
	m := make(map[int]E)
	for i, v := range s {
		m[i] = v
	}
	for _, v := range m {
		return v
	}
	return s[0]
}

type X[U any]struct {
	u U
}
func (x X)Foo(v any){} 		// ERROR:cannot use generic type X[U any] without instantiation
func (x X[U])Bar(v any){} 	// OK
func (x X)Say[V any](v V){} // ERROR:Method cannot have type parameters

x := X{u: "hello"} // '"hello"' (type string) cannot be represented by the type U

func GenericSum[T ~int | float32 | ~int64 | float64 | string](ns ...T) (sum T)

type sumT interface {
	~int | float32 | ~int64 | float64 | string
}
func GenericSum[T sumT](elems ...T) (sum T) {
	for _, v := range elems {
		sum += v
	}
	return sum
}

// Ia 模板类型集，表示只能接收指针类型的参数类型
type Ia[T any] interface {
	*T
}
// 此声明会报错 -- 不能作为参数使用，无法实例化模板，必须用中括号表示泛型模板来告知编译器进行实例化
func bar1(v Ia[any]) {} // Interface includes constraint element '*T', can only be used in type parameters
// 可作为类型集合使用 -- 此方法只接受指针参数
func barA[E any, T Ia[E]](v T) { fmt.Println("barA", *v) }
// 限制只能输入int类型值的指针
func barAA[T Ia[int]](v T) { fmt.Println("barAA", *v) }
// 限制只能输入any类型值的指针，其他值需要先显示转换成any类型才能传参
func barAAA[T Ia[any]](v T) { fmt.Println("barAAA", *v) }

type A interface {
	int | string
	float64
}
type B interface {
	int
	String()string
}

type S interface {
    string | fmt.Stringer // ERROR:cannot use fmt.Stringer in union (fmt.Stringer contains methods)
}

type S[Ts ...comparable] struct {
	elems ...Ts
}

func Equal[T comparable](v1, v2 T) bool {
	type a struct{} // ERROR:type declarations inside generic functions are not currently supported
	return v1 == v2
}

a, b = w < x, y > (z)

struct{ (T(int)) }
interface{ (T(int)) }

type Ib[T any] interface {
	Foo()
}
func bar2(T Ib[int]) {
	T.Foo()
}