1 files changed, 128 insertions, 0 deletions
diff --git a/test/typeparam/setsimp.dir/a.go b/test/typeparam/setsimp.dir/a.go
new file mode 100644
index 0000000000..92449ce956
--- /dev/null
+++ b/test/typeparam/setsimp.dir/a.go
@@ -0,0 +1,128 @@
+// 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
+
+// SliceEqual reports whether two slices are equal: the same length and all
+// elements equal. All floating point NaNs are considered equal.
+func SliceEqual[Elem comparable](s1, s2 []Elem) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if v1 != v2 {
+			isNaN := func(f Elem) bool { return f != f }
+			if !isNaN(v1) || !isNaN(v2) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// A Set is a set of elements of some type.
+type Set[Elem comparable] struct {
+	m map[Elem]struct{}
+}
+
+// Make makes a new set.
+func Make[Elem comparable]() Set[Elem] {
+	return Set[Elem]{m: make(map[Elem]struct{})}
+}
+
+// Add adds an element to a set.
+func (s Set[Elem]) Add(v Elem) {
+	s.m[v] = struct{}{}
+}
+
+// Delete removes an element from a set. If the element is not present
+// in the set, this does nothing.
+func (s Set[Elem]) Delete(v Elem) {
+	delete(s.m, v)
+}
+
+// Contains reports whether v is in the set.
+func (s Set[Elem]) Contains(v Elem) bool {
+	_, ok := s.m[v]
+	return ok
+}
+
+// Len returns the number of elements in the set.
+func (s Set[Elem]) Len() int {
+	return len(s.m)
+}
+
+// Values returns the values in the set.
+// The values will be in an indeterminate order.
+func (s Set[Elem]) Values() []Elem {
+	r := make([]Elem, 0, len(s.m))
+	for v := range s.m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// Equal reports whether two sets contain the same elements.
+func Equal[Elem comparable](s1, s2 Set[Elem]) bool {
+	if len(s1.m) != len(s2.m) {
+		return false
+	}
+	for v1 := range s1.m {
+		if !s2.Contains(v1) {
+			return false
+		}
+	}
+	return true
+}
+
+// Copy returns a copy of s.
+func (s Set[Elem]) Copy() Set[Elem] {
+	r := Set[Elem]{m: make(map[Elem]struct{}, len(s.m))}
+	for v := range s.m {
+		r.m[v] = struct{}{}
+	}
+	return r
+}
+
+// AddSet adds all the elements of s2 to s.
+func (s Set[Elem]) AddSet(s2 Set[Elem]) {
+	for v := range s2.m {
+		s.m[v] = struct{}{}
+	}
+}
+
+// SubSet removes all elements in s2 from s.
+// Values in s2 that are not in s are ignored.
+func (s Set[Elem]) SubSet(s2 Set[Elem]) {
+	for v := range s2.m {
+		delete(s.m, v)
+	}
+}
+
+// Intersect removes all elements from s that are not present in s2.
+// Values in s2 that are not in s are ignored.
+func (s Set[Elem]) Intersect(s2 Set[Elem]) {
+	for v := range s.m {
+		if !s2.Contains(v) {
+			delete(s.m, v)
+		}
+	}
+}
+
+// Iterate calls f on every element in the set.
+func (s Set[Elem]) Iterate(f func(Elem)) {
+	for v := range s.m {
+		f(v)
+	}
+}
+
+// Filter deletes any elements from s for which f returns false.
+func (s Set[Elem]) Filter(f func(Elem) bool) {
+	for v := range s.m {
+		if !f(v) {
+			delete(s.m, v)
+		}
+	}
+}