samber · samber · Oct 2, 2025 · Sep 23, 2025 · Sep 23, 2025 · Sep 23, 2025
diff --git a/channel_test.go b/channel_test.go
@@ -2,7 +2,6 @@ package lo
 
 import (
 	"context"
-	"math/rand"
 	"testing"
 	"time"
 
@@ -117,9 +116,6 @@ func TestDispatchingStrategyRandom(t *testing.T) {
 	testWithTimeout(t, 10*time.Millisecond)
 	is := assert.New(t)
 
-	// with this seed, the order of random channels are: 1 - 0
-	rand.Seed(14)
-
 	children := createChannels[int](2, 2)
 	rochildren := channelsToReadOnly(children)
 	defer closeChannels(children)

diff --git a/find_test.go b/find_test.go
@@ -36,6 +36,7 @@ func TestHasPrefix(t *testing.T) {
 
 	is.True(HasPrefix([]int{1, 2, 3, 4}, []int{1, 2}))
 	is.False(HasPrefix([]int{1, 2, 3, 4}, []int{42}))
+	is.True(HasPrefix([]int{1, 2, 3, 4}, nil))
 }
 
 func TestHasSuffix(t *testing.T) {
@@ -44,6 +45,7 @@ func TestHasSuffix(t *testing.T) {
 
 	is.True(HasSuffix([]int{1, 2, 3, 4}, []int{3, 4}))
 	is.False(HasSuffix([]int{1, 2, 3, 4}, []int{42}))
+	is.True(HasSuffix([]int{1, 2, 3, 4}, nil))
 }
 
 func TestFind(t *testing.T) {
@@ -721,8 +723,6 @@ func TestSample(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)
 
-	rand.Seed(time.Now().UnixNano())
-
 	result1 := Sample([]string{"a", "b", "c"})
 	result2 := Sample([]string{})
 
@@ -747,8 +747,6 @@ func TestSamples(t *testing.T) {
 	t.Parallel()
 	is := assert.New(t)
 
-	rand.Seed(time.Now().UnixNano())
-
 	result1 := Samples([]string{"a", "b", "c"}, 3)
 	result2 := Samples([]string{}, 3)
 

diff --git a/it/channel.go b/it/channel.go
@@ -0,0 +1,50 @@
+//go:build go1.23
+
+package it
+
+import (
+	"iter"
+
+	"github.com/samber/lo"
+)
+
+// SeqToChannel returns a read-only channel of collection elements.
+func SeqToChannel[T any](bufferSize int, collection iter.Seq[T]) <-chan T {
+	ch := make(chan T, bufferSize)
+
+	go func() {
+		for item := range collection {
+			ch <- item
+		}
+
+		close(ch)
+	}()
+
+	return ch
+}
+
+// SeqToChannel2 returns a read-only channel of collection elements.
+func SeqToChannel2[K, V any](bufferSize int, collection iter.Seq2[K, V]) <-chan lo.Tuple2[K, V] {
+	ch := make(chan lo.Tuple2[K, V], bufferSize)
+
+	go func() {
+		for k, v := range collection {
+			ch <- lo.Tuple2[K, V]{A: k, B: v}
+		}
+
+		close(ch)
+	}()
+
+	return ch
+}
+
+// ChannelToSeq returns a sequence built from channels items. Blocks until channel closes.
+func ChannelToSeq[T any](ch <-chan T) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range ch {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}
diff --git a/it/channel_test.go b/it/channel_test.go
@@ -0,0 +1,60 @@
+//go:build go1.23
+
+package it
+
+import (
+	"maps"
+	"slices"
+	"testing"
+
+	"github.com/samber/lo"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSeqToChannel(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	ch := SeqToChannel(2, values(1, 2, 3))
+
+	r1, ok1 := <-ch
+	r2, ok2 := <-ch
+	r3, ok3 := <-ch
+	is.True(ok1)
+	is.Equal(1, r1)
+	is.True(ok2)
+	is.Equal(2, r2)
+	is.True(ok3)
+	is.Equal(3, r3)
+
+	_, ok4 := <-ch
+	is.False(ok4)
+}
+
+func TestSeqToChannel2(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	ch := SeqToChannel2(2, maps.All(map[string]int{"a": 1, "b": 2, "c": 3}))
+
+	r1, ok1 := <-ch
+	r2, ok2 := <-ch
+	r3, ok3 := <-ch
+	is.True(ok1)
+	is.True(ok2)
+	is.True(ok3)
+	is.ElementsMatch([]lo.Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}, {A: "c", B: 3}}, []lo.Tuple2[string, int]{r1, r2, r3})
+
+	_, ok4 := <-ch
+	is.False(ok4)
+}
+
+func TestChannelToSeq(t *testing.T) {
+	t.Parallel()
+	is := assert.New(t)
+
+	ch := SeqToChannel(2, values(1, 2, 3))
+	items := ChannelToSeq(ch)
+
+	is.Equal([]int{1, 2, 3}, slices.Collect(items))
+}