Files
lo/it/channel.go
T
Nathan Baulch 43cef1f439 feat: new iter package (#672)
* lint: pin golangci-lint version

* lint: fix issues triggered by go1.23 upgrade

* feat: new iter package

* lint: fix linter issues

* fix: restore go1.18

* fix: rename package to "it"

* feat: assign multiple sequences of maps

* fix: panic in DropRight if n = 0

* docs: fix incorrect non-iter helper references

* feat: implement Invert helper

* feat: helpers for creating and checking empty sequences

* feat: implement Reverse helper

* feat: implement ReduceRight helper

* feat: implement Shuffle helper

* feat: implement Sample* helpers

* refactor: rename helpers with Seq convention

* feat: implement SeqToChannel2 helper

* feat: implement HasPrefix/HasSuffix helpers

* chore: port recent changes

* perf: only iterate collection once in Every

* refactor: reduce dupe code by reusing helpers internally

* perf: reuse internal Mode slice

* feat: implement Length helper

* chore: duplicate unit tests for *I helpers

* fix: omit duplicates in second Intersect list

* feat: intersect more than 2 sequences

* feat: implement Drain helper

* feat: implement Seq/Seq2 conversion helpers

* refactor: rename *Right* to *Last*

* chore: minor cleanup

* refactor: consistent predicate/transform parameter names

* perf: abort Slice/Subset once upper bound reached

* refactor: rename IsSortedByKey to IsSortedBy

* refactor: reuse more helpers internally

* feat: implement Cut* helpers

* feat: implement Trim* helpers

* perf: reduce allocations

* docs: describe iteration and allocation expectations

* Update .github/workflows/lint.yml

---------

Co-authored-by: Samuel Berthe <dev@samuel-berthe.fr>
2025-10-02 19:23:16 +02:00

51 lines
933 B
Go

//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
}
}
}
}