Support Stringer for remaining iters

Author: BooleanCat

iter/runes.go

@@ -1,6 +1,10 @@
 package iter
 
-import "github.com/BooleanCat/go-functional/option"
+import (
+	"fmt"
+
+	"github.com/BooleanCat/go-functional/option"
+)
 
 // RunesIter iterator, see [Runes].
 type RunesIter struct {
@@ -20,7 +24,15 @@ func (iter *RunesIter) Next() option.Option[rune] {
 	return option.Some(iter.runes[iter.index-1])
 }
 
-var _ Iterator[rune] = new(RunesIter)
+// String implements the [fmt.Stringer] interface
+func (iter RunesIter) String() string {
+	return "Iterator<Runes>"
+}
+
+var (
+	_ fmt.Stringer   = new(RunesIter)
+	_ Iterator[rune] = new(RunesIter)
+)
 
 // Runes instantiates a [*RunesIter] that will yield a rune on iteration.
 func Runes[T string | []rune](runes T) *RunesIter {

iter/runes_test.go

@@ -22,6 +22,11 @@ func ExampleRunes_slice() {
 	// Output: 世界
 }
 
+func ExampleRunesIter_String() {
+	fmt.Println(iter.Runes("Hello, 世界!"))
+	// Output: Iterator<Runes>
+}
+
 func TestRunes(t *testing.T) {
 	runes := iter.Runes("Hello, 世界!").Collect()
 	assert.SliceEqual[rune](t, runes, []rune{'H', 'e', 'l', 'l', 'o', ',', ' ', '世', '界', '!'})
@@ -41,3 +46,9 @@ func TestRunesEmptySlice(t *testing.T) {
 	runes := iter.Runes([]rune{}).Collect()
 	assert.Empty[rune](t, runes)
 }
+
+func TestRunesIter_String(t *testing.T) {
+	runes := iter.Runes("Hello, 世界!")
+	assert.Equal(t, fmt.Sprintf("%s", runes), "Iterator<Runes>")  //nolint:gosimple
+	assert.Equal(t, fmt.Sprintf("%s", *runes), "Iterator<Runes>") //nolint:gosimple
+}

iter/take.go

@@ -1,6 +1,11 @@
 package iter
 
-import "github.com/BooleanCat/go-functional/option"
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/BooleanCat/go-functional/option"
+)
 
 // TakeIter iterator, see [Take].
 type TakeIter[T any] struct {
@@ -33,4 +38,13 @@ func (iter *TakeIter[T]) Next() option.Option[T] {
 	return next
 }
 
-var _ Iterator[struct{}] = new(TakeIter[struct{}])
+// String implements the [fmt.Stringer] interface
+func (iter TakeIter[T]) String() string {
+	var instanceOfT T
+	return fmt.Sprintf("Iterator<Take, type=%s>", reflect.TypeOf(instanceOfT))
+}
+
+var (
+	_ Iterator[int]      = new(TakeIter[int])
+	_ Iterator[struct{}] = new(TakeIter[struct{}])
+)

iter/take_test.go

@@ -31,6 +31,11 @@ func ExampleTake_method() {
 	// None
 }
 
+func ExampleTakeIter_String() {
+	fmt.Println(iter.Take[int](iter.Count(), 2))
+	// Output: Iterator<Take, type=int>
+}
+
 func TestTakeIter(t *testing.T) {
 	iter := iter.Take[int](iter.Count(), 2)
 	assert.Equal(t, iter.Next().Unwrap(), 0)
@@ -51,3 +56,9 @@ func TestTakeExhausted(t *testing.T) {
 	assert.True(t, iter.Next().IsNone())
 	assert.Equal(t, delegate.NextCallCount(), 1)
 }
+
+func TestTakeString(t *testing.T) {
+	numbers := iter.Take[int](iter.Count(), 2)
+	assert.Equal(t, fmt.Sprintf("%s", numbers), "Iterator<Take, type=int>")  //nolint:gosimple
+	assert.Equal(t, fmt.Sprintf("%s", *numbers), "Iterator<Take, type=int>") //nolint:gosimple
+}

iter/zip.go

@@ -2,6 +2,7 @@ package iter
 
 import (
 	"fmt"
+	"reflect"
 
 	"github.com/BooleanCat/go-functional/option"
 )
@@ -61,4 +62,17 @@ func (iter *ZipIter[T, U]) Next() option.Option[Pair[T, U]] {
 	return option.Some(Pair[T, U]{v1, v2})
 }
 
-var _ Iterator[Pair[struct{}, struct{}]] = new(ZipIter[struct{}, struct{}])
+// String implements the [fmt.Stringer] interface
+func (iter ZipIter[T, U]) String() string {
+	var (
+		instanceOfT T
+		instanceOfU U
+	)
+
+	return fmt.Sprintf("Iterator<Zip, type=Pair<%s, %s>>", reflect.TypeOf(instanceOfT), reflect.TypeOf(instanceOfU))
+}
+
+var (
+	_ fmt.Stringer                       = new(ZipIter[int, int])
+	_ Iterator[Pair[struct{}, struct{}]] = new(ZipIter[struct{}, struct{}])
+)

iter/zip_test.go

@@ -18,6 +18,14 @@ func ExampleZip() {
 	// Output:[(0, 1) (2, 3) (4, 5)]
 }
 
+func ExampleZipIter_String() {
+	evens := iter.Filter[int](iter.Count(), filters.IsEven[int])
+	odds := iter.Filter[int](iter.Count(), filters.IsOdd[int])
+
+	fmt.Println(iter.Zip[int, int](evens, odds))
+	// Output: Iterator<Zip, type=Pair<int, int>>
+}
+
 func TestPairStringer(t *testing.T) {
 	foo := map[string]interface{}{
 		"text": "Random Text",
@@ -74,3 +82,13 @@ func TestZipSecondExhaustedDelegate(t *testing.T) {
 	assert.True(t, zipped.Next().IsNone())
 	assert.Equal(t, delegate.NextCallCount(), 1)
 }
+
+func TestZipString(t *testing.T) {
+	evens := iter.Filter[int](iter.Count(), filters.IsEven[int])
+	odds := iter.Filter[int](iter.Count(), filters.IsOdd[int])
+	zipped := iter.Zip[int, int](evens, odds)
+	expected := "Iterator<Zip, type=Pair<int, int>>"
+
+	assert.Equal(t, fmt.Sprintf("%s", zipped), expected)  //nolint:gosimple
+	assert.Equal(t, fmt.Sprintf("%s", *zipped), expected) //nolint:gosimple
+}