Fixed collection sequence helpers so nil iter.Seq values no longer panic and instead behave like empty sequences.

Author: acabarbaye

changes/20260608103100.bugfix

@@ -0,0 +1 @@
+Fixed collection sequence helpers so nil `iter.Seq` values no longer panic and instead behave like empty sequences.

utils/collection/conditions.go

@@ -128,10 +128,7 @@ func Any(slice []bool) bool {
 
 // AnySequence returns true if there is at least one element of the slice which is true.
 func AnySequence(seq iter.Seq[bool]) bool {
-	if seq == nil {
-		return false
-	}
-	for e := range seq {
+	for e := range sequenceOrEmpty(seq) {
 		if e {
 			return true
 		}
@@ -147,7 +144,7 @@ func AnyTrue(values ...bool) bool {
 // AnyFalseSequence returns true if there is at least one element of the sequence which is false. If the sequence is empty, it also returns true.
 func AnyFalseSequence(eq iter.Seq[bool]) bool {
 	hasElements := false
-	for e := range eq {
+	for e := range sequenceOrEmpty(eq) {
 		hasElements = true
 		if !e {
 			return true

utils/collection/filter.go

@@ -129,7 +129,7 @@ func FilterRef[S ~[]E, E any](s S, f FilterRefFunc[E]) S {
 //   - https://pkg.go.dev/iter
 func FilterSequence[E any](s iter.Seq[E], f Predicate[E]) (result iter.Seq[E]) {
 	return func(yield func(E) bool) {
-		for v := range s {
+		for v := range sequenceOrEmpty(s) {
 			if f(v) && !yield(v) {
 				return
 			}

utils/collection/find.go

@@ -29,11 +29,8 @@ func Find(slice *[]string, val string) (int, bool) {
 // element and true when a match is found. If elements is nil or no
 // match exists, it returns -1 and false.
 func FindInSequence[E any](elements iter.Seq[E], predicate Predicate[E]) (int, bool) {
-	if elements == nil {
-		return -1, false
-	}
 	idx := atomic.NewUint64(0)
-	for e := range elements {
+	for e := range sequenceOrEmpty(elements) {
 		if predicate(e) {
 			return safecast.ToInt(idx.Load()), true
 		}

utils/collection/iterator.go

@@ -24,6 +24,18 @@ type OperationWithoutErrorFunc[E any] func(E)
 // OperationWithoutErrorRefFunc defines an operation on a pointer that does not return an error.
 type OperationWithoutErrorRefFunc[E any] func(*E)
 
+// EmptySequence returns a sequence that yields no values.
+func EmptySequence[T any]() iter.Seq[T] {
+	return func(func(T) bool) {}
+}
+
+func sequenceOrEmpty[T any](s iter.Seq[T]) iter.Seq[T] {
+	if s == nil {
+		return EmptySequence[T]()
+	}
+	return s
+}
+
 // toOperationFunc adapts an OperationRefFunc to an OperationFunc by
 // converting the value to an optional reference.
 func toOperationFunc[E any](f OperationRefFunc[E]) OperationFunc[E] {
@@ -53,7 +65,7 @@ func convertOperationWithoutError[E any](f OperationWithoutErrorFunc[E]) Operati
 // returns a non-EOF error, iteration stops and that error is returned.
 // If f returns EOF, the EOF is ignored and iteration ends without error.
 func Each[T any](s iter.Seq[T], f OperationFunc[T]) error {
-	for e := range s {
+	for e := range sequenceOrEmpty(s) {
 		err := f(e)
 		if err != nil {
 			err = commonerrors.Ignore(err, commonerrors.ErrEOF)

utils/collection/mapping.go

@@ -60,7 +60,7 @@ func MapSequence[T1 any, T2 any](s iter.Seq[T1], f MapFunc[T1, T2]) iter.Seq[T2]
 // value.
 func MapSequenceWithError[T1 any, T2 any](s iter.Seq[T1], f MapWithErrorFunc[T1, T2]) iter.Seq[T2] {
 	return func(yield func(T2) bool) {
-		for v := range s {
+		for v := range sequenceOrEmpty(s) {
 			mapped, err := f(v)
 			if err != nil || !yield(mapped) {
 				return
@@ -89,7 +89,7 @@ func MapSequenceRef[T1 any, T2 any](s iter.Seq[T1], f MapRefFunc[T1, T2]) iter.S
 // combined with validation or other error-producing transformations.
 func MapSequenceRefWithError[T1 any, T2 any](s iter.Seq[T1], f MapRefWithErrorFunc[T1, T2]) iter.Seq[T2] {
 	return func(yield func(T2) bool) {
-		for v := range s {
+		for v := range sequenceOrEmpty(s) {
 			mapped, err := f(field.ToOptionalOrNilIfEmpty(v))
 			if err != nil || mapped == nil || !yield(*mapped) {
 				return

utils/collection/queue/channel_queue.go

@@ -4,6 +4,7 @@ import (
 	"iter"
 	"slices"
 
+	"github.com/ARM-software/golang-utils/utils/collection"
 	"github.com/ARM-software/golang-utils/utils/commonerrors"
 )
 
@@ -38,6 +39,9 @@ func (q *ChanQueue[T]) Enqueue(values ...T) {
 // EnqueueSequence adds a sequence to the queue.
 // This blocks if the queue is full.
 func (q *ChanQueue[T]) EnqueueSequence(seq iter.Seq[T]) {
+	if seq == nil {
+		seq = collection.EmptySequence[T]()
+	}
 	for v := range seq {
 		q.ch <- v
 	}

utils/collection/queue/queue.go

@@ -3,6 +3,8 @@ package queue
 import (
 	"iter"
 	"slices"
+
+	"github.com/ARM-software/golang-utils/utils/collection"
 )
 
 // NewQueue returns a Queue which is not thread safe
@@ -78,6 +80,9 @@ func (s *Queue[T]) Enqueue(value ...T) {
 }
 
 func (s *Queue[T]) EnqueueSequence(seq iter.Seq[T]) {
+	if seq == nil {
+		seq = collection.EmptySequence[T]()
+	}
 	for v := range seq {
 		s.enqueue(v)
 	}

utils/collection/range.go

@@ -45,7 +45,7 @@ func RangeSequence[T safecast.IConvertible](start, stop T, step *T) iter.Seq[T]
 func rangeSequence[T safecast.IConvertible](start, stop T, step *T) (it iter.Seq[T], length int) {
 	s := field.Optional[T](step, 1)
 	if s == 0 {
-		it = func(yield func(T) bool) {}
+		it = EmptySequence[T]()
 		return
 	}
 	length = determineRangeLength[T](start, stop, s)

utils/collection/reduce.go

@@ -47,7 +47,7 @@ func Reduce[T1, T2 any](s []T1, accumulator T2, f ReduceFunc[T1, T2]) T2 {
 //   - https://pkg.go.dev/iter
 func ReducesSequence[T1, T2 any](s iter.Seq[T1], accumulator T2, f ReduceFunc[T1, T2]) T2 {
 	result := accumulator
-	for e := range s {
+	for e := range sequenceOrEmpty(s) {
 		result = f(result, e)
 	}
 	return result