implement difference

Author: dashjay

pkg/xiter/README.md

@@ -504,6 +504,14 @@ func ToMap[K comparable, V any](seq Seq2[K, V]) (out map[K]V) {
 	return maps.Collect(iter.Seq2[K, V](seq))
 }
 
+func ToMapFromSeq[K comparable, V any](seq Seq[K], fn func(k K) V) (out map[K]V) {
+	out = make(map[K]V)
+	for k := range seq {
+		out[k] = fn(k)
+	}
+	return out
+}
+
 func FromMapKeys[K comparable, V any](m map[K]V) Seq[K] {
 	return Seq[K](maps.Keys(m))
 }

pkg/xiter/xiter.go

@@ -111,3 +111,31 @@ func FromChan[T any](in <-chan T) Seq[T] {
 		}
 	}
 }
+
+// Difference returns two sequences: the first sequence contains elements that are in the left sequence but not in the right sequence,
+// and the second sequence contains elements that are in the right sequence but not in the left sequence.
+//
+// EXAMPLE:
+//
+//	left := []int{1, 2, 3, 4}
+//	right := []int{3, 4, 5, 6}
+//	onlyLeft, onlyRight := Difference(FromSlice(left), FromSlice(right))
+//	// onlyLeft 👉 [1 2]
+//	// onlyRight 👉 [5 6]
+func Difference[T comparable](left Seq[T], right Seq[T]) (onlyLeft Seq[T], onlyRight Seq[T]) {
+	leftMap := ToMapFromSeq(left, func(k T) struct{} {
+		return struct{}{}
+	})
+	rightMap := ToMapFromSeq(right, func(k T) struct{} {
+		return struct{}{}
+	})
+
+	return Filter(func(v T) bool {
+			_, ok := rightMap[v]
+			return !ok
+		}, left),
+		Filter(func(v T) bool {
+			_, ok := leftMap[v]
+			return !ok
+		}, right)
+}

pkg/xiter/xiter_common.go

@@ -1,9 +1,10 @@
 package xiter_test
 
 import (
+	"testing"
+
 	"github.com/dashjay/xiter/pkg/xiter"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestXIterCommon(t *testing.T) {
@@ -72,4 +73,12 @@ func TestXIterCommon(t *testing.T) {
 		seq := xiter.FromChan(ch)
 		testLimit(t, seq, 1)
 	})
+
+	t.Run("difference", func(t *testing.T) {
+		left := xiter.FromSlice(_range(0, 10))
+		right := xiter.FromSlice(_range(5, 15))
+		onlyLeft, onlyRight := xiter.Difference(left, right)
+		assert.Equal(t, _range(0, 5), xiter.ToSlice(onlyLeft))
+		assert.Equal(t, _range(10, 15), xiter.ToSlice(onlyRight))
+	})
 }

pkg/xiter/xiter_common_test.go

@@ -349,6 +349,15 @@ func ToMap[K comparable, V any](seq Seq2[K, V]) (out map[K]V) {
 	return out
 }
 
+func ToMapFromSeq[K comparable, V any](seq Seq[K], fn func(k K) V) (out map[K]V) {
+	out = make(map[K]V)
+	seq(func(k K) bool {
+		out[k] = fn(k)
+		return true
+	})
+	return out
+}
+
 func FromMapKeys[K comparable, V any](m map[K]V) Seq[K] {
 	return func(yield func(K) bool) {
 		for k := range m {

pkg/xiter/xiter_old.go

@@ -24,6 +24,7 @@ import "github.com/dashjay/xiter/pkg/xslice"
 - [func ContainsAny\[T comparable\]\(in \[\]T, v \[\]T\) bool](<#ContainsAny>)
 - [func ContainsBy\[T any\]\(in \[\]T, f func\(T\) bool\) bool](<#ContainsBy>)
 - [func Count\[T any\]\(in \[\]T\) int](<#Count>)
+- [func Difference\[T comparable, Slice \~\[\]T\]\(left, right Slice\) \(onlyLeft, onlyRight Slice\)](<#Difference>)
 - [func Filter\[T any, Slice \~\[\]T\]\(in Slice, f func\(T\) bool\) Slice](<#Filter>)
 - [func Find\[T any\]\(in \[\]T, f func\(T\) bool\) \(val T, found bool\)](<#Find>)
 - [func FindO\[T any\]\(in \[\]T, f func\(T\) bool\) optional.O\[T\]](<#FindO>)
@@ -327,6 +328,25 @@ xslice.Count([]int{1, 2, 3}) 👉 3
 xslice.Count([]int{}) 👉 0
 ```
 
+<a name="Difference"></a>
+## func [Difference](<https://github.com/dashjay/xiter/blob/main/pkg/xslice/xslice.go#L639>)
+
+```go
+func Difference[T comparable, Slice ~[]T](left, right Slice) (onlyLeft, onlyRight Slice)
+```
+
+Difference returns two slices: the first slice contains the elements that are in the left slice but not in the right slice, and the second slice contains the elements that are in the right slice but not in the left slice.
+
+EXAMPLE:
+
+```
+left := []int{1, 2, 3, 4, 5}
+right := []int{4, 5, 6, 7, 8}
+onlyLeft, onlyRight := xslice.Difference(left, right)
+fmt.Println(onlyLeft)  // [1 2 3]
+fmt.Println(onlyRight) // [6 7 8]
+```
+
 <a name="Filter"></a>
 ## func [Filter](<https://github.com/dashjay/xiter/blob/main/pkg/xslice/xslice.go#L576>)
 

pkg/xslice/README.md

@@ -625,3 +625,18 @@ func Last[T any, Slice ~[]T](in Slice) (T, bool) {
 func LastO[T any, Slice ~[]T](in Slice) optional.O[T] {
 	return optional.FromValue2(Last(in))
 }
+
+// Difference returns two slices: the first slice contains the elements that are in the left slice but not in the right slice,
+// and the second slice contains the elements that are in the right slice but not in the left slice.
+//
+// EXAMPLE:
+//
+//	left := []int{1, 2, 3, 4, 5}
+//	right := []int{4, 5, 6, 7, 8}
+//	onlyLeft, onlyRight := xslice.Difference(left, right)
+//	fmt.Println(onlyLeft)  // [1 2 3]
+//	fmt.Println(onlyRight) // [6 7 8]
+func Difference[T comparable, Slice ~[]T](left, right Slice) (onlyLeft, onlyRight Slice) {
+	onlyLeftSeq, onlyRightSeq := xiter.Difference(xiter.FromSlice(left), xiter.FromSlice(right))
+	return xiter.ToSlice(onlyLeftSeq), xiter.ToSlice(onlyRightSeq)
+}

pkg/xslice/xslice.go

@@ -183,6 +183,21 @@ func BenchmarkSlice(b *testing.B) {
 			}
 		})
 	})
+
+	b.Run("benchmark difference", func(b *testing.B) {
+		left := _range(0, 1000)
+		right := _range(500, 1500)
+		b.Run("xslice", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				xslice.Difference(left, right)
+			}
+		})
+		b.Run("lo", func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				lo.Difference(left, right)
+			}
+		})
+	})
 }
 
 func BenchmarkChunk(b *testing.B) {

pkg/xslice/xslice_benchmark_test.go

@@ -331,9 +331,20 @@ func TestSlices(t *testing.T) {
 
 	t.Run("first", func(t *testing.T) {
 		assert.Equal(t, 1, xslice.FirstO([]int{1, 2, 3}).Must())
+		assert.False(t, xslice.FirstO([]int{}).Ok())
 	})
 
 	t.Run("last", func(t *testing.T) {
 		assert.Equal(t, 3, xslice.LastO([]int{1, 2, 3}).Must())
+		assert.False(t, xslice.LastO([]int{}).Ok())
 	})
+
+	t.Run("difference", func(t *testing.T) {
+		left := []int{1, 2, 3, 4, 5}
+		right := []int{4, 5, 6, 7, 8}
+		onlyLeft, onlyRight := xslice.Difference(left, right)
+		assert.Equal(t, []int{1, 2, 3}, onlyLeft)
+		assert.Equal(t, []int{6, 7, 8}, onlyRight)
+	})
+
 }