透彻！Java快速转型到Go—Go泛型的Instantiation Cycle坑点

// 这里是当时出错的地方，这个函数是不能用的，当时算法设计有点问题。
​
type Option[T any] struct {
  opt T
}
​
type Options[T any] []Option[T]
​
type Stream[T any, Slice ~[]T] struct {
  options  *Options[T]
  source   *Slice
  parallel bool
}
​
​
func NewOptionsStream[Opt any, Opts Options[Opt]](source *[]Opts) *Stream[Options[Opt], []Options[Opt]] {
    resOptions := make(Options[Options[Opt]], 0)
    sourceList := make([]Options[Opt], 0)
    for i := 0; i < len(*source); i++ {
       t := Options[Opt]((*source)[i])
       resOptions = append(resOptions, Option[Options[Opt]]{opt: t})
       sourceList = append(sourceList, t)
    }
    return &Stream[Options[Opt], []Options[Opt]]{
       options: (*Options[Options[Opt]])(&resOptions),
       source:  &sourceList,
    }
}
​
// 这下面的代码略看即可，具体的代码已经修改了，这是当时找到报错时候的版本，部分逻辑有问题，下一期出Stream流的复刻！
func (s *Stream[T, Slice]) OrderBy(desc bool, orderBy algorithm.HashComputeFunction) *Stream[T, Slice] {
    size := len(*s.options)
    data := make([]Options[T], 0)
    // opt opt opt opt -> opts opts
    lists.Partition(*s.options, optional.IsTrue(s.parallel, size<<4^0x1, 1)).ForEach(func(pos int, options []Option[T]) error {
       data = append(data, options)
       return nil
    }, false, nil)
​
    res := NewOptionsStream[T, Options[T]](&data).Map(func(options Options[T]) any {
       sort.SliceStable(options, func(i, j int) bool {
          if desc {
             return orderBy((options)[i].opt) > orderBy((options)[j].opt)
          } else {
             return orderBy((options)[i].opt) < orderBy((options)[j].opt)
          }
       })
       return options
    }).Map(func(v any) any {
​
       i := v.([]Option[T])
       ress := NewOptionStream(&i).Map(func(item Option[T]) any {
          return item.opt
       }).ToList()
       return ress
​
    }).ToList()
    re := make([]T, len(res))
    result := ToStream(&res).Reduce(re, func(cntValue any, nxt any) any {
       ts := cntValue.([]T)
       nxts := nxt.([]T)
       if len(ts) == 0 {
          return nxts
       }
       if len(nxts) == 0 {
          return ts
       }
       lenRe := len(re)
       lenNxt := len(nxts)
       for i := 0; i < min(lenRe, lenNxt); i++ {
          if orderBy(ts[i]) > orderBy(nxts[i]) {
             if desc {
                re = append(re, ts[i])
             } else {
                re = append(re, nxts[i])
             }
          } else {
             if desc {
                re = append(re, ts[i])
             } else {
                re = append(re, nxts[i])
             }
          }
       }
       return re
    }, nil).(Slice)
    stream := ToStream(&result)
    return stream
}

../../container/stream/stream.go:14:13: instantiation cycle:
  ../../container/stream/stream.go:30:66: T instantiated as T
  ../../container/stream/stream.go:219:17: T instantiated as []Option[T]

// 传入source的实际类型是 *[]Options[T]，这个时候Opt是T
​
    // 这里 Opt 是 Options[Opt] 的类型参数
    // Stream 的类型参数又是 Options[Opt]
    // 造成了类型参数的互相依赖
func NewOptionsStream[Opt any, Opts Options[Opt]](source *[]Opts) *Stream[Options[Opt], []Options[Opt]] {
    resOptions := make(Options[Options[Opt]], 0)
    sourceList := make([]Options[Opt], 0)
    for i := 0; i < len(*source); i++ {
       t := Options[Opt]((*source)[i])
       resOptions = append(resOptions, Option[Options[Opt]]{opt: t})
       sourceList = append(sourceList, t)
    }
    return &Stream[Options[Opt], []Options[Opt]]{
       options: (*Options[Options[Opt]])(&resOptions),
       source:  &sourceList,
    }
}

type slice[E any] struct{ elems []E }
​
func (s slice[E]) chunk(n int) slice[[]E] {
  return slice[[]E]{elems: [][]E{}}
}
​
func Test_123(t *testing.T) {
  chunks := slice[int]{
    elems: []int{1, 2, 3},
  }.chunk(2)
  for _, chunk := range chunks.elems {
    t.Log(chunk)
  }
}

# github.com/karosown/katool/test [github.com/karosown/katool/test.test]
./other_test.go:7:12: instantiation cycle:
  ./other_test.go:9:38: E instantiated as []E