Ensure filter iters do not repeatedly call exhausted delegates

Author: Tom Godkin

iter/filter.go

@@ -4,21 +4,27 @@ import "github.com/BooleanCat/go-functional/option"
 
 // FilterIter implements `Filter`. See `Filter`'s documentation.
 type FilterIter[T any] struct {
-	iter Iterator[T]
-	fun  func(T) bool
+	iter      Iterator[T]
+	fun       func(T) bool
+	exhausted bool
 }
 
 // Filter instantiates a `FilterIter` that selectively yields only results that
 // cause the provided function to return `true`.
 func Filter[T any](iter Iterator[T], fun func(T) bool) *FilterIter[T] {
-	return &FilterIter[T]{iter, fun}
+	return &FilterIter[T]{iter, fun, false}
 }
 
 // Next implements the Iterator interface for `Filter`.
 func (iter *FilterIter[T]) Next() option.Option[T] {
+	if iter.exhausted {
+		return option.None[T]()
+	}
+
 	for {
 		value, ok := iter.iter.Next().Value()
 		if !ok {
+			iter.exhausted = true
 			return option.None[T]()
 		}
 
@@ -34,21 +40,28 @@ var _ Iterator[struct{}] = new(FilterIter[struct{}])
 // cause the provided function to return `false`.
 func Exclude[T any](iter Iterator[T], fun func(T) bool) *FilterIter[T] {
 	inverse := func(t T) bool { return !fun(t) }
-	return &FilterIter[T]{iter, inverse}
+	return &FilterIter[T]{iter, inverse, false}
 }
 
 type FilterMapIter[T any, U any] struct {
-	itr Iterator[T]
-	fn  func(T) option.Option[U]
+	iter      Iterator[T]
+	fn        func(T) option.Option[U]
+	exhausted bool
 }
 
-func (flt *FilterMapIter[T, U]) Next() option.Option[U] {
+func (iter *FilterMapIter[T, U]) Next() option.Option[U] {
+	if iter.exhausted {
+		return option.None[U]()
+	}
+
 	for {
-		val, ok := flt.itr.Next().Value()
+		val, ok := iter.iter.Next().Value()
 		if !ok {
+			iter.exhausted = true
 			return option.None[U]()
 		}
-		result := flt.fn(val)
+
+		result := iter.fn(val)
 		if result.IsSome() {
 			return result
 		}
@@ -61,5 +74,5 @@ var _ Iterator[struct{}] = new(FilterMapIter[struct{}, struct{}])
 // it allows the user to filter elements by returning a None variant and to transform
 // elements by returning a Some variant.
 func FilterMap[T any, U any](itr Iterator[T], fun func(T) option.Option[U]) Iterator[U] {
-	return &FilterMapIter[T, U]{itr, fun}
+	return &FilterMapIter[T, U]{itr, fun, false}
 }

iter/filter_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/BooleanCat/go-functional/internal/assert"
+	"github.com/BooleanCat/go-functional/internal/fakes"
 	"github.com/BooleanCat/go-functional/iter"
 	"github.com/BooleanCat/go-functional/iter/filters"
 	"github.com/BooleanCat/go-functional/option"
@@ -65,13 +66,31 @@ func TestFilterEmpty(t *testing.T) {
 	assert.True(t, evens.Next().IsNone())
 }
 
+func TestFilterExhausted(t *testing.T) {
+	delegate := new(fakes.Iterator[int])
+	ones := iter.Filter[int](delegate, func(_ int) bool { return true })
+
+	assert.True(t, ones.Next().IsNone())
+	assert.True(t, ones.Next().IsNone())
+	assert.Equal(t, delegate.NextCallCount(), 1)
+}
+
 func TestExclude(t *testing.T) {
 	isEven := func(a int) bool { return a%2 == 0 }
 	evens := iter.Exclude[int](iter.Count(), isEven)
 	assert.Equal(t, evens.Next().Unwrap(), 1)
 	assert.Equal(t, evens.Next().Unwrap(), 3)
 }
 
+func TestExcludeExhausted(t *testing.T) {
+	delegate := new(fakes.Iterator[int])
+	ones := iter.Exclude[int](delegate, func(_ int) bool { return false })
+
+	assert.True(t, ones.Next().IsNone())
+	assert.True(t, ones.Next().IsNone())
+	assert.Equal(t, delegate.NextCallCount(), 1)
+}
+
 func TestFilterMap(t *testing.T) {
 	selectEvenAndDouble := func(x int) option.Option[int] {
 		if x%2 > 0 {
@@ -106,3 +125,12 @@ func TestFilterMapEmpty(t *testing.T) {
 
 	assert.Empty(t, iter.Collect(fltMapEmpty))
 }
+
+func TestFilterMapExhausted(t *testing.T) {
+	delegate := new(fakes.Iterator[int])
+	ones := iter.FilterMap[int](delegate, func(_ int) option.Option[int] { return option.Some(1) })
+
+	assert.True(t, ones.Next().IsNone())
+	assert.True(t, ones.Next().IsNone())
+	assert.Equal(t, delegate.NextCallCount(), 1)
+}