Go泛型缺陷?Go Stream是如何解决Go不支持泛型方法的问题的？

func TestStream(t *testing.T) {
  items := []TestItem{
      {itemNum: 7, itemValue: "item7"},{itemNum: 6, itemValue: "item6"},
      {itemNum: 1, itemValue: "item1"},{itemNum: 2, itemValue: "item2"},
      {itemNum: 3, itemValue: "item3"},{itemNum: 4, itemValue: "item4"},
      {itemNum: 5, itemValue: "item5"},{itemNum: 5, itemValue: "item5"},
      {itemNum: 5, itemValue: "item5"},{itemNum: 8, itemValue: "item8"},
    }
    res := Of(items...).Filter(func(item TestItem) bool {
      // 过滤掉1的值
      return item.itemNum != 4
    }).Distinct(func(item TestItem) any {
      // 按itemNum 去重
      return item.itemNum
    }).Sorted(func(a, b TestItem) bool {
      // 按itemNum升序排序
      return a.itemNum < b.itemNum
    }).Skip(1).Limit(6).Reverse().ToSlice()
    fmt.Println(res)
}

type Student struct {
 Num   int
 Score int
 Age   int
 Name  string
}
studentMap := map[int]Student{
  1: {Num: 1, Name: "小明", Score: 3, Age: 26},
  2: {Num: 2, Name: "小红", Score: 4, Age: 27},
  3: {Num: 3, Name: "小李", Score: 5, Age: 24},
  4: {Num: 4, Name: "老王", Score: 1, Age: 23},
  5: {Num: 5, Name: "小王", Score: 2, Age: 24},
  6: {Num: 6, Name: "小绿", Score: 2, Age: 24},
  7: {Num: 7, Name: "小蓝", Score: 3, Age: 29},
  8: {Num: 8, Name: "小橙", Score: 3, Age: 30},
  9: {Num: 9, Name: "小黄", Score: 4, Age: 29},
  10: {Num: 10, Name: "小黑", Score: 5, Age: 15},
  11: {Num: 11, Name: "小紫", Score: 3, Age: 15},
  12: {Num: 12, Name: "小刘", Score: 2, Age: 15},
}

// v1.0.* 的代码这样实现
res := Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).Map(func(n int) any {
  return studentMap[n]
 }).Filter(func(s any) bool {
  // 这里需要强转
  tempS := s.(Student)
  // 过滤掉1的
  return tempS.Score != 1
 }).Collect(collectors.GroupingBy(func(t any) int {
  return t.(Student).Score
 }, func(t any) any {
  return t
 }, func(t1 []any) {
  sort.Slice(t1, func(i, j int) bool {
   return t1[i].(Student).Age < t1[j].(Student).Age
  })
 }))
 println(res)

package p1
// S 是一个普通的struct,但是包含一个泛型方法Identity.
type S struct{}
// Identity 一个泛型方法，支持任意类型.
func (S) Identity[T any](v T) T { return v }

package p2
// HasIdentity 定义了一个接口，支持任意实现了泛型方法Identity的类型.
type HasIdentity interface {
 Identity[T any](T) T
}

package p3
import "p2"
// CheckIdentity 是一个普通函数，检查实参是不是实现了HasIdentity接口，如果是，则调用这个接口的泛型方法Identity.
func CheckIdentity(v interface{}) {
 if vi, ok := v.(p2.HasIdentity); ok {
  if got := vi.Identity[int](0); got != 0 {
   panic(got)
  }
 }
}

package p4
import (
 "p1"
 "p3"
)
// CheckSIdentity 传参S给CheckIdentity.
func CheckSIdentity() {
 p3.CheckIdentity(p1.S{})
}

student_group = groupby(stus, key=lambda s: s['score'])

// v1.1.* 的代码这样实现
res := GroupingBy(Map(Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), func(n int) Student {
  // 注意 这里的返回类型可以是目标类型了
  return studentMap[n]
 }).Filter(func(s Student) bool {
  // 这里过滤也不需要转换类型
  // 过滤掉1的
  return s.Score != 1
 }), func(t Student) int {
   // key
  return t.Score
 }, func(t Student) Student {
    // v item
  return t
 }, func(t1 []Student) {
  // 按年龄降序排列
  sort.Slice(t1, func(i, j int) bool {
   return t1[i].Age > t1[j].Age
  })
 })
 println(res)