Simplify iterator chaining for Collect

Author: BooleanCat

iter/chain.go

@@ -4,14 +4,17 @@ import "github.com/BooleanCat/go-functional/option"
 
 // ChainIter iterator, see [Chain].
 type ChainIter[T any] struct {
+	BaseIter[T]
 	iterators     []Iterator[T]
 	iteratorIndex int
 }
 
 // Chain instantiates a [*ChainIter] that will yield all items in the provided
 // iterators to exhaustion first to last.
 func Chain[T any](iterators ...Iterator[T]) *ChainIter[T] {
-	return &ChainIter[T]{iterators, 0}
+	iter := &ChainIter[T]{iterators: iterators}
+	iter.BaseIter = BaseIter[T]{iter}
+	return iter
 }
 
 // Next implements the [Iterator] interface.
@@ -32,12 +35,6 @@ func (iter *ChainIter[T]) Next() option.Option[T] {
 
 var _ Iterator[struct{}] = new(ChainIter[struct{}])
 
-// Collect is a convenience method for [Collect], providing this iterator as an
-// argument.
-func (iter *ChainIter[T]) Collect() []T {
-	return Collect[T](iter)
-}
-
 // ForEach is a convenience method for [ForEach], providing this iterator as an
 // argument.
 func (iter *ChainIter[T]) ForEach(callback func(T)) {

iter/chain_test.go

@@ -46,11 +46,6 @@ func TestChainExhausted(t *testing.T) {
 	assert.Equal(t, delegate2.NextCallCount(), 1)
 }
 
-func TestChainCollect(t *testing.T) {
-	numbers := iter.Chain[int](iter.Lift([]int{1, 2}), iter.Lift([]int{3, 4})).Collect()
-	assert.SliceEqual(t, numbers, []int{1, 2, 3, 4})
-}
-
 func TestChainForEach(t *testing.T) {
 	total := 0
 

iter/channel.go

@@ -4,13 +4,16 @@ import "github.com/BooleanCat/go-functional/option"
 
 // ChannelIter iterator, see [FromChannel].
 type ChannelIter[T any] struct {
+	BaseIter[T]
 	item chan T
 }
 
 // FromChannel instantiates a [*ChannelIter] that will yield each value from
 // the provided channel.
 func FromChannel[T any](ch chan T) *ChannelIter[T] {
-	return &ChannelIter[T]{ch}
+	iter := &ChannelIter[T]{item: ch}
+	iter.BaseIter = BaseIter[T]{iter}
+	return iter
 }
 
 // Next implements the [Iterator] interface.
@@ -26,12 +29,6 @@ func (iter *ChannelIter[T]) Next() option.Option[T] {
 
 var _ Iterator[struct{}] = new(ChannelIter[struct{}])
 
-// Collect is a convenience method for [Collect], providing this iterator as an
-// argument.
-func (iter *ChannelIter[T]) Collect() []T {
-	return Collect[T](iter)
-}
-
 // ForEach is a convenience method for [ForEach], providing this iterator as an
 // argument.
 func (iter *ChannelIter[T]) ForEach(callback func(T)) {

iter/channel_test.go

@@ -46,19 +46,6 @@ func TestFromChannelEmpty(t *testing.T) {
 	assert.True(t, iter.FromChannel(ch).Next().IsNone())
 }
 
-func TestFromChannelCollect(t *testing.T) {
-	ch := make(chan int)
-
-	go func() {
-		ch <- 1
-		ch <- 2
-		close(ch)
-	}()
-
-	numbers := iter.FromChannel(ch).Collect()
-	assert.SliceEqual(t, numbers, []int{1, 2})
-}
-
 func TestFromChannelForEach(t *testing.T) {
 	ch := make(chan int)
 

iter/counter.go

@@ -4,14 +4,17 @@ import "github.com/BooleanCat/go-functional/option"
 
 // CountIter iterator, see [Count].
 type CountIter struct {
+	BaseIter[int]
 	index int
 }
 
 // Count instantiates a [*CountIter] that will iterate over 0 and the
 // natural numbers. Count is functionally "unlimited" although it does not
 // protect against the integer limit.
 func Count() *CountIter {
-	return new(CountIter)
+	iter := new(CountIter)
+	iter.BaseIter = BaseIter[int]{iter}
+	return iter
 }
 
 // Next implements the [Iterator] interface.

iter/cycle.go

@@ -4,6 +4,7 @@ import "github.com/BooleanCat/go-functional/option"
 
 // CycleIter iterator, see [Cycle].
 type CycleIter[T any] struct {
+	BaseIter[T]
 	iter  Iterator[T]
 	items []T
 	index int
@@ -20,7 +21,9 @@ type CycleIter[T any] struct {
 // is exhausted before the first call to Next() in which case this iterator
 // will always yield None.
 func Cycle[T any](iter Iterator[T]) *CycleIter[T] {
-	return &CycleIter[T]{iter, make([]T, 0), 0}
+	iterator := &CycleIter[T]{iter: iter, items: make([]T, 0)}
+	iterator.BaseIter = BaseIter[T]{iterator}
+	return iterator
 }
 
 // Next implements the [Iterator] interface.

iter/drop.go

@@ -4,6 +4,7 @@ import "github.com/BooleanCat/go-functional/option"
 
 // DropIter iterator, see [Drop].
 type DropIter[T any] struct {
+	BaseIter[T]
 	iter      Iterator[T]
 	count     uint
 	dropped   bool
@@ -13,7 +14,9 @@ type DropIter[T any] struct {
 // Drop instantiates a [*DropIter] that will skip the number of items of its
 // wrapped iterator by the provided count.
 func Drop[T any](iter Iterator[T], count uint) *DropIter[T] {
-	return &DropIter[T]{iter, count, false, false}
+	iterator := &DropIter[T]{iter: iter, count: count}
+	iterator.BaseIter = BaseIter[T]{iterator}
+	return iterator
 }
 
 // Next implements the [Iterator] interface.
@@ -46,12 +49,6 @@ func (iter *DropIter[T]) delegateNext() option.Option[T] {
 
 var _ Iterator[struct{}] = new(DropIter[struct{}])
 
-// Collect is a convenience method for [Collect], providing this iterator as
-// an argument.
-func (iter *DropIter[T]) Collect() []T {
-	return Collect[T](iter)
-}
-
 // ForEach is a convenience method for [ForEach], providing this iterator as an
 // argument.
 func (iter *DropIter[T]) ForEach(callback func(T)) {

iter/drop_test.go

@@ -50,11 +50,6 @@ func TestDropExhaustedLater(t *testing.T) {
 	assert.Equal(t, delegate.NextCallCount(), 3)
 }
 
-func TestDropCollect(t *testing.T) {
-	numbers := iter.Drop[int](iter.Lift([]int{1, 2, 3}), 2).Collect()
-	assert.SliceEqual(t, numbers, []int{3})
-}
-
 func TestDropForEach(t *testing.T) {
 	total := 0
 

iter/exhausted.go

@@ -3,12 +3,16 @@ package iter
 import "github.com/BooleanCat/go-functional/option"
 
 // ExhaustedIter iterator, see [Exhausted].
-type ExhaustedIter[T any] struct{}
+type ExhaustedIter[T any] struct {
+	BaseIter[T]
+}
 
 // Exhausted instantiates an [*ExhaustedIter] that will immediately be
 // exhausted (Next will always return a None variant).
 func Exhausted[T any]() *ExhaustedIter[T] {
-	return new(ExhaustedIter[T])
+	iter := new(ExhaustedIter[T])
+	iter.BaseIter = BaseIter[T]{iter}
+	return iter
 }
 
 // Next implements the [Iterator] interface.
@@ -18,12 +22,6 @@ func (iter *ExhaustedIter[T]) Next() option.Option[T] {
 
 var _ Iterator[struct{}] = new(ExhaustedIter[struct{}])
 
-// Collect is a convenience method for [Collect], providing this iterator as
-// an argument.
-func (iter *ExhaustedIter[T]) Collect() []T {
-	return Collect[T](iter)
-}
-
 // Find is a convenience method for [Find], providing this iterator as an
 // argument.
 func (iter *ExhaustedIter[T]) Find(predicate func(T) bool) option.Option[T] {

iter/exhausted_test.go

@@ -17,10 +17,6 @@ func TestExhausted(t *testing.T) {
 	assert.True(t, iter.Exhausted[int]().Next().IsNone())
 }
 
-func TestExhaustedCollect(t *testing.T) {
-	assert.Empty[int](t, iter.Exhausted[int]().Collect())
-}
-
 func TestExhaustedForEach(t *testing.T) {
 	total := 0