Initial commit: Go 1.23 release state

test/typeparam/issue48716.dir/a.go

@@ -0,0 +1,51 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+type Pair[L, R any] struct {
+	L L
+	R R
+}
+
+func Two[L, R any](l L, r R) Pair[L, R] {
+	return Pair[L, R]{L: l, R: r}
+}
+
+type Map[K, V any] interface {
+	Put(K, V)
+	Len() int
+	Iterate(func(Pair[K, V]) bool)
+}
+
+type HashMap[K comparable, V any] struct {
+	m map[K]V
+}
+
+func NewHashMap[K comparable, V any](capacity int) HashMap[K, V] {
+	var m map[K]V
+	if capacity >= 1 {
+		m = make(map[K]V, capacity)
+	} else {
+		m = map[K]V{}
+	}
+
+	return HashMap[K, V]{m: m}
+}
+
+func (m HashMap[K, V]) Put(k K, v V) {
+	m.m[k] = v
+}
+
+func (m HashMap[K, V]) Len() int {
+	return len(m.m)
+}
+
+func (m HashMap[K, V]) Iterate(cb func(Pair[K, V]) bool) {
+	for k, v := range m.m {
+		if !cb(Two(k, v)) {
+			return
+		}
+	}
+}

test/typeparam/issue48716.dir/main.go

@@ -0,0 +1,58 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"./a"
+)
+
+// Creates copy of set
+func Copy[T comparable](src MapSet[T]) (dst MapSet[T]) {
+	dst = HashSet[T](src.Len())
+	Fill(src, dst)
+	return
+}
+
+// Fill src from dst
+func Fill[T any](src, dst MapSet[T]) {
+	src.Iterate(func(t T) bool {
+		dst.Add(t)
+		return true
+	})
+	return
+}
+
+type MapSet[T any] struct {
+	m a.Map[T, struct{}]
+}
+
+func HashSet[T comparable](capacity int) MapSet[T] {
+	return FromMap[T](a.NewHashMap[T, struct{}](capacity))
+}
+
+func FromMap[T any](m a.Map[T, struct{}]) MapSet[T] {
+	return MapSet[T]{
+		m: m,
+	}
+}
+
+func (s MapSet[T]) Add(t T) {
+	s.m.Put(t, struct{}{})
+}
+
+func (s MapSet[T]) Len() int {
+	return s.m.Len()
+}
+
+func (s MapSet[T]) Iterate(cb func(T) bool) {
+	s.m.Iterate(func(p a.Pair[T, struct{}]) bool {
+		return cb(p.L)
+	})
+}
+
+func main() {
+	x := FromMap[int](a.NewHashMap[int, struct{}](1))
+	Copy[int](x)
+}