Adapt project to current 1.23 iter API (#106)

Adapt project to current 1.23 iter API

Please provide a brief description of the change.

- All iterators now natively return and use the Seq types rather than this projects type alias, favouring compatibility with the standard library over convenience features like chaining.
- Added iterators for the Seq2 variants of existing iterators
- Renamed Lift to Values and moved to future shadow package slices (to be deleted when Go 1.23 is released)
- Renamed LiftHashMap to All and moved to future shadow package maps (to be deleted when Go 1.23 is released)

Author: BooleanCat

future/maps/maps.go

@@ -0,0 +1,29 @@
+// Package maps provides early implementations of map-related functions
+// available in Go 1.23+.
+package maps
+
+import "iter"
+
+// All returns an iterator over key-value pairs from m. The iteration order is
+// not specified and is not guaranteed to be the same from one call to the
+// next.
+func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for key, value := range m {
+			if !yield(key, value) {
+				return
+			}
+		}
+	}
+}
+
+// Collect collects key-value pairs from seq into a new map and returns it.
+func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V {
+	m := make(map[K]V)
+
+	for key, value := range seq {
+		m[key] = value
+	}
+
+	return m
+}

future/maps/maps_test.go

@@ -0,0 +1,80 @@
+package maps_test
+
+import (
+	"fmt"
+	"iter"
+	"sort"
+	"testing"
+
+	"github.com/BooleanCat/go-functional/v2/future/maps"
+	"github.com/BooleanCat/go-functional/v2/internal/assert"
+)
+
+func ExampleAll() {
+	for key, value := range maps.All(map[int]string{1: "one", 2: "two", 3: "three"}) {
+		fmt.Println(key, value)
+	}
+}
+
+type keyValuePair[K comparable, V any] struct {
+	key   K
+	value V
+}
+
+func TestAll(t *testing.T) {
+	t.Parallel()
+
+	values := make([]keyValuePair[int, string], 0, 3)
+
+	for key, value := range maps.All(map[int]string{1: "one", 2: "two", 3: "three"}) {
+		values = append(values, keyValuePair[int, string]{key, value})
+	}
+
+	sort.Slice(values, func(i, j int) bool {
+		return values[i].key < values[j].key
+	})
+
+	assert.SliceEqual(t, values, []keyValuePair[int, string]{
+		{1, "one"},
+		{2, "two"},
+		{3, "three"},
+	})
+}
+
+func TestAllEmpty(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, len(maps.Collect(maps.All(map[int]string{}))), 0)
+}
+
+func TestAllTerminateEarly(t *testing.T) {
+	t.Parallel()
+
+	_, stop := iter.Pull2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}))
+	stop()
+}
+
+func ExampleCollect() {
+	numbers := maps.Collect(maps.All(map[int]string{1: "one", 2: "two"}))
+
+	fmt.Println(numbers[0])
+	fmt.Println(numbers[1])
+	// Output
+	// one
+	// two
+}
+
+func TestCollect(t *testing.T) {
+	t.Parallel()
+
+	numbers := maps.Collect(maps.All(map[int]string{1: "one", 2: "two"}))
+
+	assert.Equal(t, numbers[1], "one")
+	assert.Equal(t, numbers[2], "two")
+}
+
+func TestCollectEmpty(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, len(maps.Collect(maps.All(map[int]string{}))), 0)
+}

future/slices/slices.go

@@ -0,0 +1,27 @@
+// Package slices provides early implementations of slice-related functions
+// available in Go 1.23+.
+package slices
+
+import "iter"
+
+// Values returns an iterator over the slice elements, starting with s[0].
+func Values[Slice ~[]E, E any](slice Slice) iter.Seq[E] {
+	return func(yield func(E) bool) {
+		for _, value := range slice {
+			if !yield(value) {
+				return
+			}
+		}
+	}
+}
+
+// Collect collects values from seq into a new slice and returns it.
+func Collect[E any](seq iter.Seq[E]) []E {
+	slice := make([]E, 0)
+
+	for item := range seq {
+		slice = append(slice, item)
+	}
+
+	return slice
+}

future/slices/slices_test.go

@@ -0,0 +1,47 @@
+package slices_test
+
+import (
+	"fmt"
+	"iter"
+	"testing"
+
+	"github.com/BooleanCat/go-functional/v2/future/slices"
+	"github.com/BooleanCat/go-functional/v2/internal/assert"
+)
+
+func ExampleValues() {
+	for number := range slices.Values([]int{1, 2, 3}) {
+		fmt.Println(number)
+	}
+
+	// Output:
+	// 1
+	// 2
+	// 3
+}
+
+func TestValuesEmpty(t *testing.T) {
+	t.Parallel()
+
+	for number := range slices.Values([]int{}) {
+		t.Error("unexpected", number)
+	}
+}
+
+func TestValuesTerminateEarly(t *testing.T) {
+	t.Parallel()
+
+	_, stop := iter.Pull(slices.Values([]int{1, 2, 3}))
+	stop()
+}
+
+func ExampleCollect() {
+	fmt.Println(slices.Collect(slices.Values([]int{1, 2, 3})))
+	// Output: [1 2 3]
+}
+
+func TestCollectEmpty(t *testing.T) {
+	t.Parallel()
+
+	assert.Empty[int](t, slices.Collect(slices.Values([]int{})))
+}

internal/assert/assert.go

@@ -65,7 +65,7 @@ func EqualElements[T comparable](t *testing.T, a, b []T) {
 	}
 }
 
-func Empty[S any, T []S | ~string](t *testing.T, items T) {
+func Empty[E any, Slice ~[]E | ~string](t *testing.T, items Slice) {
 	t.Helper()
 
 	if len(items) != 0 {

iter/count.go

@@ -3,12 +3,15 @@ package iter
 import "iter"
 
 // Count yields all non-negative integers in ascending order.
-func Count() Iterator[int] {
-	return Iterator[int](iter.Seq[int](func(yield func(int) bool) {
-		for i := 0; ; i++ {
+func Count[V ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~int | ~int8 | ~int16 | ~int32 | ~int64]() iter.Seq[V] {
+	return func(yield func(V) bool) {
+		var i V
+
+		for {
 			if !yield(i) {
 				return
 			}
+			i++
 		}
-	}))
+	}
 }

iter/count_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func ExampleCount() {
-	for i := range iter.Count() {
+	for i := range iter.Count[int]() {
 		if i >= 3 {
 			break
 		}
@@ -26,6 +26,6 @@ func ExampleCount() {
 func TestCountTerminateEarly(t *testing.T) {
 	t.Parallel()
 
-	_, stop := it.Pull(it.Seq[int](iter.Count()))
+	_, stop := it.Pull(iter.Count[int]())
 	stop()
 }

iter/drop.go

@@ -4,8 +4,8 @@ import "iter"
 
 // Drop yields all values from a delegate [Iterator] except the first `count`
 // values.
-func Drop[V any](delegate Iterator[V], count int) Iterator[V] {
-	return Iterator[V](iter.Seq[V](func(yield func(V) bool) {
+func Drop[V any](delegate iter.Seq[V], count int) iter.Seq[V] {
+	return func(yield func(V) bool) {
 		for value := range delegate {
 			if count > 0 {
 				count--
@@ -16,10 +16,32 @@ func Drop[V any](delegate Iterator[V], count int) Iterator[V] {
 				return
 			}
 		}
-	}))
+	}
 }
 
 // Drop is a convenience method for chaining [Drop] on [Iterator]s.
-func (iter Iterator[V]) Drop(count int) Iterator[V] {
-	return Drop[V](iter, count)
+func (iterator Iterator[V]) Drop(count int) Iterator[V] {
+	return Iterator[V](Drop(iter.Seq[V](iterator), count))
+}
+
+// Drop2 yields all pairs of values from a delegate [Iterator2] except the
+// first `count` pairs.
+func Drop2[V, W any](delegate iter.Seq2[V, W], count int) iter.Seq2[V, W] {
+	return func(yield func(V, W) bool) {
+		for v, w := range delegate {
+			if count > 0 {
+				count--
+				continue
+			}
+
+			if !yield(v, w) {
+				return
+			}
+		}
+	}
+}
+
+// Drop is a convenience method for chaining [Drop] on [Iterator2]s.
+func (iterator Iterator2[V, W]) Drop(count int) Iterator2[V, W] {
+	return Iterator2[V, W](Drop2(iter.Seq2[V, W](iterator), count))
 }

iter/drop_test.go

@@ -3,13 +3,17 @@ package iter_test
 import (
 	"fmt"
 	it "iter"
+	sl "slices"
 	"testing"
 
+	"github.com/BooleanCat/go-functional/v2/future/maps"
+	"github.com/BooleanCat/go-functional/v2/future/slices"
+	"github.com/BooleanCat/go-functional/v2/internal/assert"
 	"github.com/BooleanCat/go-functional/v2/iter"
 )
 
 func ExampleDrop() {
-	for value := range iter.Drop(iter.Lift([]int{1, 2, 3, 4, 5}), 2) {
+	for value := range iter.Drop(slices.Values([]int{1, 2, 3, 4, 5}), 2) {
 		fmt.Println(value)
 	}
 
@@ -20,7 +24,7 @@ func ExampleDrop() {
 }
 
 func ExampleDrop_method() {
-	for value := range iter.Lift([]int{1, 2, 3, 4, 5}).Drop(2) {
+	for value := range iter.Iterator[int](slices.Values([]int{1, 2, 3, 4, 5})).Drop(2) {
 		fmt.Println(value)
 	}
 
@@ -33,14 +37,62 @@ func ExampleDrop_method() {
 func TestDropTerminateEarly(t *testing.T) {
 	t.Parallel()
 
-	_, stop := it.Pull(it.Seq[int](iter.Drop(iter.Lift([]int{1, 2, 3}), 2)))
+	_, stop := it.Pull(iter.Drop(slices.Values([]int{1, 2, 3}), 2))
 	stop()
 }
 
 func TestDropEmpty(t *testing.T) {
 	t.Parallel()
 
-	for _ = range iter.Drop(iter.Lift([]int{}), 2) {
-		t.Error("unexpected")
+	assert.Empty[int](t, slices.Collect(iter.Drop(slices.Values([]int{}), 2)))
+}
+
+func ExampleDrop2() {
+	numbers := maps.Collect(iter.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 1))
+
+	fmt.Println(len(numbers))
+	// Output: 2
+}
+
+func ExampleDrop2_method() {
+	numbers := iter.Iterator2[int, string](maps.All(map[int]string{1: "one", 2: "two", 3: "three"})).Drop(1)
+
+	fmt.Println(len(maps.Collect(it.Seq2[int, string](numbers))))
+	// Output: 2
+}
+
+func TestDrop2(t *testing.T) {
+	t.Parallel()
+
+	keys := []int{1, 2, 3}
+	values := []string{"one", "two", "three"}
+
+	numbers := maps.Collect(iter.Drop2(iter.Zip(slices.Values(keys), slices.Values(values)), 1))
+
+	assert.Equal(t, len(numbers), 2)
+
+	for key := range numbers {
+		assert.True(t, sl.Contains(keys, key))
 	}
 }
+
+func TestDrop2Empty(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, len(maps.Collect(iter.Drop2(maps.All(map[int]string{}), 1))), 0)
+}
+
+func TestDrop2Zero(t *testing.T) {
+	t.Parallel()
+
+	numbers := maps.Collect(iter.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 0))
+
+	assert.Equal(t, len(numbers), 3)
+}
+
+func TestDrop2TerminateEarly(t *testing.T) {
+	t.Parallel()
+
+	_, stop := it.Pull2(iter.Drop2(maps.All(map[int]string{1: "one", 2: "two", 3: "three"}), 1))
+	stop()
+}