Merge branch 'main' into feature/marshal-bson

Author: ryclarke

.github/workflows/ci.yml

@@ -4,19 +4,18 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.20.1, 1.21.1]
+        go-version: [1.20.x, 1.21.x, 1.22.x, 1.23.x, 1.24.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
-    - name: Install Go
-      uses: actions/setup-go@v3
-      with:
-        go-version: ${{ matrix.go-version }}
-        stable: false
-    - name: Checkout code
-      uses: actions/checkout@v3
-    - name: Test
-      run: |
-        go test -v -race ./...
-        # go vet ./...
-        # go test -bench=.
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Test
+        run: |
+          go test -v -race ./...
+          # go vet ./...
+          # go test -bench=.

README.md

@@ -9,6 +9,17 @@ The missing `generic` set collection for the Go language.  Until Go has sets bui
 ## Psst
 * Hi there, 👋! Do you use or have interest in the [Zig programming language](https://ziglang.org/) created by Andrew Kelley? If so, the golang-set project has a new sibling project: [ziglang-set](https://github.com/deckarep/ziglang-set)! Come check it out!
 
+## Update 3/14/2025
+* Packaged version: `2.8.0` introduces support for true iterators for Go 1.23+. Please see [issue #141](https://github.com/deckarep/golang-set/issues/141)
+for further details on the implications of how iterations work between older Go versions vs newer Go versions. Additionally, this
+release has a minor unit-test spelling fix.
+
+## Update 12/3/2024
+* Packaged version: `2.7.0` fixes a long-standing bug with *JSON Unmarshaling*. A large refactor in the interest of performance
+introduced this bug and there was no way around it but to revert the code back to how it was previously. The performance
+difference was likely negligible to begin with. JSON Marshaling and Unmarshaling is now properly supported again without
+needing to do workarounds.
+
 ## Update 3/5/2023
 * Packaged version: `2.2.0` release includes a refactor to minimize pointer indirection, better method documentation standards and a few constructor convenience methods to increase ergonomics when appending items `Append` or creating a new set from an exist `Map`.
 * supports `new generic` syntax

set.go

@@ -75,6 +75,10 @@ type Set[T comparable] interface {
 	// given items are in the set.
 	ContainsAny(val ...T) bool
 
+	// ContainsAnyElement returns whether at least one of the
+	// given element are in the set.
+	ContainsAnyElement(other Set[T]) bool
+
 	// Difference returns the difference between this set
 	// and other. The returned set will contain
 	// all elements of this set that are not also
@@ -262,3 +266,13 @@ func NewThreadUnsafeSetFromMapKeys[T comparable, V any](val map[T]V) Set[T] {
 
 	return s
 }
+
+// Elements returns an iterator that yields the elements of the set. Starting
+// with Go 1.23, users can use a for loop to iterate over it.
+func Elements[T comparable](s Set[T]) func(func(element T) bool) {
+	return func(yield func(element T) bool) {
+		s.Each(func(t T) bool {
+			return !yield(t)
+		})
+	}
+}

set123_test.go

@@ -0,0 +1,38 @@
+//go:build go1.23
+// +build go1.23
+
+package mapset
+
+import (
+	"testing"
+)
+
+func Test_Elements123(t *testing.T) {
+	a := NewSet[string]()
+
+	a.Add("Z")
+	a.Add("Y")
+	a.Add("X")
+	a.Add("W")
+
+	b := NewSet[string]()
+	for elem := range Elements(a) {
+		b.Add(elem)
+	}
+
+	if !a.Equal(b) {
+		t.Error("The sets are not equal after iterating (Each) through the first set")
+	}
+
+	var count int
+	for range Elements(a) {
+		if count == 2 {
+			break
+		}
+		count++
+	}
+
+	if count != 2 {
+		t.Error("Iteration should stop on the way")
+	}
+}

set_test.go

@@ -398,6 +398,33 @@ func Test_ContainsAnySet(t *testing.T) {
 	}
 }
 
+func Test_ContainsAnyElement(t *testing.T) {
+	a := NewSet[int]()
+	a.Add(1)
+	a.Add(3)
+	a.Add(5)
+
+	b := NewSet[int]()
+	a.Add(2)
+	a.Add(4)
+	a.Add(6)
+
+	if ret := a.ContainsAnyElement(b); ret {
+		t.Errorf("set a not contain any element in set b")
+	}
+
+	a.Add(10)
+
+	if ret := a.ContainsAnyElement(b); ret {
+		t.Errorf("set a not contain any element in set b")
+	}
+
+	b.Add(10)
+
+	if ret := a.ContainsAnyElement(b); !ret {
+		t.Errorf("set a contain 10")
+	}
+}
 func Test_ClearSet(t *testing.T) {
 	a := makeSetInt([]int{2, 5, 9, 10})
 
@@ -1248,7 +1275,7 @@ func Test_EmptySetProperties(t *testing.T) {
 
 	c = a.Intersect(empty)
 	if !c.Equal(empty) {
-		t.Error("The intesection of any set with the empty set is supposed to be the empty set")
+		t.Error("The intersection of any set with the empty set is supposed to be the empty set")
 	}
 
 	if empty.Cardinality() != 0 {
@@ -1346,6 +1373,38 @@ func Test_NewThreadUnsafeSetFromMapKey_Strings(t *testing.T) {
 	}
 }
 
+func Test_Elements(t *testing.T) {
+	a := NewSet[string]()
+
+	a.Add("Z")
+	a.Add("Y")
+	a.Add("X")
+	a.Add("W")
+
+	b := NewSet[string]()
+	Elements(a)(func(elem string) bool {
+		b.Add(elem)
+		return true
+	})
+
+	if !a.Equal(b) {
+		t.Error("The sets are not equal after iterating (Each) through the first set")
+	}
+
+	var count int
+	Elements(a)(func(elem string) bool {
+		if count == 2 {
+			return false
+		}
+		count++
+		return true
+	})
+
+	if count != 2 {
+		t.Error("Iteration should stop on the way")
+	}
+}
+
 func Test_Example(t *testing.T) {
 	/*
 	   requiredClasses := NewSet()

threadsafe.go

@@ -33,7 +33,7 @@ import (
 
 type threadSafeSet[T comparable] struct {
 	sync.RWMutex
-	uss threadUnsafeSet[T]
+	uss *threadUnsafeSet[T]
 }
 
 func newThreadSafeSet[T comparable]() *threadSafeSet[T] {
@@ -86,6 +86,19 @@ func (t *threadSafeSet[T]) ContainsAny(v ...T) bool {
 	return ret
 }
 
+func (t *threadSafeSet[T]) ContainsAnyElement(other Set[T]) bool {
+	o := other.(*threadSafeSet[T])
+
+	t.RLock()
+	o.RLock()
+
+	ret := t.uss.ContainsAnyElement(o.uss)
+
+	t.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
 func (t *threadSafeSet[T]) IsEmpty() bool {
 	return t.Cardinality() == 0
 }
@@ -127,7 +140,7 @@ func (t *threadSafeSet[T]) Union(other Set[T]) Set[T] {
 	t.RLock()
 	o.RLock()
 
-	unsafeUnion := t.uss.Union(o.uss).(threadUnsafeSet[T])
+	unsafeUnion := t.uss.Union(o.uss).(*threadUnsafeSet[T])
 	ret := &threadSafeSet[T]{uss: unsafeUnion}
 	t.RUnlock()
 	o.RUnlock()
@@ -140,7 +153,7 @@ func (t *threadSafeSet[T]) Intersect(other Set[T]) Set[T] {
 	t.RLock()
 	o.RLock()
 
-	unsafeIntersection := t.uss.Intersect(o.uss).(threadUnsafeSet[T])
+	unsafeIntersection := t.uss.Intersect(o.uss).(*threadUnsafeSet[T])
 	ret := &threadSafeSet[T]{uss: unsafeIntersection}
 	t.RUnlock()
 	o.RUnlock()
@@ -153,7 +166,7 @@ func (t *threadSafeSet[T]) Difference(other Set[T]) Set[T] {
 	t.RLock()
 	o.RLock()
 
-	unsafeDifference := t.uss.Difference(o.uss).(threadUnsafeSet[T])
+	unsafeDifference := t.uss.Difference(o.uss).(*threadUnsafeSet[T])
 	ret := &threadSafeSet[T]{uss: unsafeDifference}
 	t.RUnlock()
 	o.RUnlock()
@@ -166,7 +179,7 @@ func (t *threadSafeSet[T]) SymmetricDifference(other Set[T]) Set[T] {
 	t.RLock()
 	o.RLock()
 
-	unsafeDifference := t.uss.SymmetricDifference(o.uss).(threadUnsafeSet[T])
+	unsafeDifference := t.uss.SymmetricDifference(o.uss).(*threadUnsafeSet[T])
 	ret := &threadSafeSet[T]{uss: unsafeDifference}
 	t.RUnlock()
 	o.RUnlock()
@@ -181,7 +194,7 @@ func (t *threadSafeSet[T]) Clear() {
 
 func (t *threadSafeSet[T]) Remove(v T) {
 	t.Lock()
-	delete(t.uss, v)
+	delete(*t.uss, v)
 	t.Unlock()
 }
 
@@ -194,25 +207,25 @@ func (t *threadSafeSet[T]) RemoveAll(i ...T) {
 func (t *threadSafeSet[T]) Cardinality() int {
 	t.RLock()
 	defer t.RUnlock()
-	return len(t.uss)
+	return len(*t.uss)
 }
 
 func (t *threadSafeSet[T]) Each(cb func(T) bool) {
 	t.RLock()
-	for elem := range t.uss {
+	defer t.RUnlock()
+	for elem := range *t.uss {
 		if cb(elem) {
 			break
 		}
 	}
-	t.RUnlock()
 }
 
 func (t *threadSafeSet[T]) Iter() <-chan T {
 	ch := make(chan T)
 	go func() {
 		t.RLock()
 
-		for elem := range t.uss {
+		for elem := range *t.uss {
 			ch <- elem
 		}
 		close(ch)
@@ -228,7 +241,7 @@ func (t *threadSafeSet[T]) Iterator() *Iterator[T] {
 	go func() {
 		t.RLock()
 	L:
-		for elem := range t.uss {
+		for elem := range *t.uss {
 			select {
 			case <-stopCh:
 				break L
@@ -257,7 +270,7 @@ func (t *threadSafeSet[T]) Equal(other Set[T]) bool {
 func (t *threadSafeSet[T]) Clone() Set[T] {
 	t.RLock()
 
-	unsafeClone := t.uss.Clone().(threadUnsafeSet[T])
+	unsafeClone := t.uss.Clone().(*threadUnsafeSet[T])
 	ret := &threadSafeSet[T]{uss: unsafeClone}
 	t.RUnlock()
 	return ret
@@ -277,9 +290,10 @@ func (t *threadSafeSet[T]) Pop() (T, bool) {
 }
 
 func (t *threadSafeSet[T]) ToSlice() []T {
-	keys := make([]T, 0, t.Cardinality())
 	t.RLock()
-	for elem := range t.uss {
+	l := len(*t.uss)
+	keys := make([]T, 0, l)
+	for elem := range *t.uss {
 		keys = append(keys, elem)
 	}
 	t.RUnlock()