set: init

Signed-off-by: oppiliappan <[e-mail]>

go.mod

···
+module tangled.org/oppi.li/set
+
+go 1.25.0

set.go

···
+package set
+
+import (
+	"iter"
+	"maps"
+)
+
+type Set[T comparable] struct {
+	data map[T]struct{}
+}
+
+func New[T comparable]() Set[T] {
+	return Set[T]{
+		data: make(map[T]struct{}),
+	}
+}
+
+func (s *Set[T]) Insert(item T) bool {
+	_, exists := s.data[item]
+	s.data[item] = struct{}{}
+	return !exists
+}
+
+func (s *Set[T]) Remove(item T) bool {
+	_, exists := s.data[item]
+	if exists {
+		delete(s.data, item)
+	}
+	return exists
+}
+
+func (s Set[T]) Contains(item T) bool {
+	_, exists := s.data[item]
+	return exists
+}
+
+func (s Set[T]) Len() int {
+	return len(s.data)
+}
+
+func (s Set[T]) IsEmpty() bool {
+	return len(s.data) == 0
+}
+
+func (s *Set[T]) Clear() {
+	s.data = make(map[T]struct{})
+}
+
+func (s Set[T]) All() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s.data {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}
+
+func (s Set[T]) Clone() Set[T] {
+	return Set[T]{
+		data: maps.Clone(s.data),
+	}
+}
+
+func (s Set[T]) Union(other Set[T]) iter.Seq[T] {
+	if s.Len() >= other.Len() {
+		return chain(s.All(), other.Difference(s))
+	} else {
+		return chain(other.All(), s.Difference(other))
+	}
+}
+
+func chain[T any](seqs ...iter.Seq[T]) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for _, seq := range seqs {
+			for item := range seq {
+				if !yield(item) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func (s Set[T]) Intersection(other Set[T]) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s.data {
+			if other.Contains(item) {
+				if !yield(item) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func (s Set[T]) Difference(other Set[T]) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s.data {
+			if !other.Contains(item) {
+				if !yield(item) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func (s Set[T]) SymmetricDifference(other Set[T]) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s.data {
+			if !other.Contains(item) {
+				if !yield(item) {
+					return
+				}
+			}
+		}
+		for item := range other.data {
+			if !s.Contains(item) {
+				if !yield(item) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func (s Set[T]) IsSubset(other Set[T]) bool {
+	for item := range s.data {
+		if !other.Contains(item) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s Set[T]) IsSuperset(other Set[T]) bool {
+	return other.IsSubset(s)
+}
+
+func (s Set[T]) IsDisjoint(other Set[T]) bool {
+	for item := range s.data {
+		if other.Contains(item) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s Set[T]) Equal(other Set[T]) bool {
+	if s.Len() != other.Len() {
+		return false
+	}
+	for item := range s.data {
+		if !other.Contains(item) {
+			return false
+		}
+	}
+	return true
+}
+
+func Collect[T comparable](seq iter.Seq[T]) Set[T] {
+	result := New[T]()
+	for item := range seq {
+		result.Insert(item)
+	}
+	return result
+}

set_test.go

···
+package set
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestNew(t *testing.T) {
+	s := New[int]()
+	if s.Len() != 0 {
+		t.Errorf("New set should be empty, got length %d", s.Len())
+	}
+	if !s.IsEmpty() {
+		t.Error("New set should be empty")
+	}
+}
+
+func TestFromSlice(t *testing.T) {
+	s := Collect(slices.Values([]int{1, 2, 3, 2, 1}))
+	if s.Len() != 3 {
+		t.Errorf("Expected length 3, got %d", s.Len())
+	}
+	if !s.Contains(1) || !s.Contains(2) || !s.Contains(3) {
+		t.Error("Set should contain all unique elements from slice")
+	}
+}
+
+func TestInsert(t *testing.T) {
+	s := New[string]()
+
+	if !s.Insert("hello") {
+		t.Error("First insert should return true")
+	}
+	if s.Insert("hello") {
+		t.Error("Duplicate insert should return false")
+	}
+	if s.Len() != 1 {
+		t.Errorf("Expected length 1, got %d", s.Len())
+	}
+}
+
+func TestRemove(t *testing.T) {
+	s := Collect(slices.Values([]int{1, 2, 3}))
+
+	if !s.Remove(2) {
+		t.Error("Remove existing element should return true")
+	}
+	if s.Remove(2) {
+		t.Error("Remove non-existing element should return false")
+	}
+	if s.Contains(2) {
+		t.Error("Element should be removed")
+	}
+	if s.Len() != 2 {
+		t.Errorf("Expected length 2, got %d", s.Len())
+	}
+}
+
+func TestContains(t *testing.T) {
+	s := Collect(slices.Values([]int{1, 2, 3}))
+
+	if !s.Contains(1) {
+		t.Error("Should contain 1")
+	}
+	if s.Contains(4) {
+		t.Error("Should not contain 4")
+	}
+}
+
+func TestClear(t *testing.T) {
+	s := Collect(slices.Values([]int{1, 2, 3}))
+	s.Clear()
+
+	if !s.IsEmpty() {
+		t.Error("Set should be empty after clear")
+	}
+	if s.Len() != 0 {
+		t.Errorf("Expected length 0, got %d", s.Len())
+	}
+}
+
+func TestIterator(t *testing.T) {
+	s := Collect(slices.Values([]int{1, 2, 3}))
+	var items []int
+
+	for item := range s.All() {
+		items = append(items, item)
+	}
+
+	slices.Sort(items)
+	expected := []int{1, 2, 3}
+	if !slices.Equal(items, expected) {
+		t.Errorf("Expected %v, got %v", expected, items)
+	}
+}
+
+func TestClone(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := s1.Clone()
+
+	if !s1.Equal(s2) {
+		t.Error("Cloned set should be equal to original")
+	}
+
+	s2.Insert(4)
+	if s1.Contains(4) {
+		t.Error("Modifying clone should not affect original")
+	}
+}
+
+func TestUnion(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2}))
+	s2 := Collect(slices.Values([]int{2, 3}))
+
+	result := Collect(s1.Union(s2))
+	expected := Collect(slices.Values([]int{1, 2, 3}))
+
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestIntersection(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{2, 3, 4}))
+
+	expected := Collect(slices.Values([]int{2, 3}))
+	result := Collect(s1.Intersection(s2))
+
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestDifference(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{2, 3, 4}))
+
+	expected := Collect(slices.Values([]int{1}))
+	result := Collect(s1.Difference(s2))
+
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestSymmetricDifference(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{2, 3, 4}))
+
+	expected := Collect(slices.Values([]int{1, 4}))
+	result := Collect(s1.SymmetricDifference(s2))
+
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestSymmetricDifferenceCommutativeProperty(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{2, 3, 4}))
+
+	result1 := Collect(s1.SymmetricDifference(s2))
+	result2 := Collect(s2.SymmetricDifference(s1))
+
+	if !result1.Equal(result2) {
+		t.Errorf("Expected %v, got %v", result1, result2)
+	}
+}
+
+func TestIsSubset(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2}))
+	s2 := Collect(slices.Values([]int{1, 2, 3}))
+
+	if !s1.IsSubset(s2) {
+		t.Error("s1 should be subset of s2")
+	}
+	if s2.IsSubset(s1) {
+		t.Error("s2 should not be subset of s1")
+	}
+}
+
+func TestIsSuperset(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{1, 2}))
+
+	if !s1.IsSuperset(s2) {
+		t.Error("s1 should be superset of s2")
+	}
+	if s2.IsSuperset(s1) {
+		t.Error("s2 should not be superset of s1")
+	}
+}
+
+func TestIsDisjoint(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2}))
+	s2 := Collect(slices.Values([]int{3, 4}))
+	s3 := Collect(slices.Values([]int{2, 3}))
+
+	if !s1.IsDisjoint(s2) {
+		t.Error("s1 and s2 should be disjoint")
+	}
+	if s1.IsDisjoint(s3) {
+		t.Error("s1 and s3 should not be disjoint")
+	}
+}
+
+func TestEqual(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2, 3}))
+	s2 := Collect(slices.Values([]int{3, 2, 1}))
+	s3 := Collect(slices.Values([]int{1, 2}))
+
+	if !s1.Equal(s2) {
+		t.Error("s1 and s2 should be equal")
+	}
+	if s1.Equal(s3) {
+		t.Error("s1 and s3 should not be equal")
+	}
+}
+
+func TestCollect(t *testing.T) {
+	s1 := Collect(slices.Values([]int{1, 2}))
+	s2 := Collect(slices.Values([]int{2, 3}))
+
+	unionSet := Collect(s1.Union(s2))
+	if unionSet.Len() != 3 {
+		t.Errorf("Expected union set length 3, got %d", unionSet.Len())
+	}
+	if !unionSet.Contains(1) || !unionSet.Contains(2) || !unionSet.Contains(3) {
+		t.Error("Union set should contain 1, 2, and 3")
+	}
+
+	diffSet := Collect(s1.Difference(s2))
+	if diffSet.Len() != 1 {
+		t.Errorf("Expected difference set length 1, got %d", diffSet.Len())
+	}
+	if !diffSet.Contains(1) {
+		t.Error("Difference set should contain 1")
+	}
+}