channel/to.go

package channel

import "container/list"

// ToSlice returns a slice containing all values read from ch
func ToSlice[T any](ch <-chan T) []T {
	s := make([]T, 0, cap(ch))
	EachSuccessive(ch, func(value T) { s = append(s, value) })
	return s
}

// ToSliceContinuous returns a slice containing all values read from ch.
// The returned slice will be a pointer slice to a continuous block of memory.
// All values will be copied.
func ToSliceContinuous[T any](ch <-chan *T) []*T {
	values := make([]T, 0, cap(ch))
	pointers := make([]*T, 0, cap(ch))
	EachSuccessive(ch, func(value *T) {
		pointers = append(pointers, value)

		if value != nil {
			values = append(values, *value)
		}
	})
	return pointers
}

// ToSliceDeref returns a slice containing all values read from ch.
// The returned slice will be a dereferenced and continuous block of memory.
// Nil pointers are ignored.
func ToSliceDeref[T any](ch <-chan *T) []T {
	s := make([]T, 0, cap(ch))
	EachSuccessive(ch, func(value *T) {
		if value != nil {
			s = append(s, *value)
		}
	})
	return s
}

// ToList returns a list.List containing all values read from ch
func ToList[T any](ch <-chan T) *list.List {
	l := list.New()
	EachSuccessive(ch, func(value T) { l.PushBack(value) })
	return l
}

// ToMap returns a map containing all values read from ch.
// The map key-value pairs are determined by f which will be called as concurrently as possible
// to build the resulting map
func ToMap[T any, K comparable, V any](ch <-chan T, f func(T) (K, V)) map[K]V {
	return ToMapWithRunner(ch, getDefaultRunner(), f)
}

// ToMap returns a map containing all values read from ch.
// The map key-value pairs are determined by f which will be called as concurrently as possible
// to build the resulting map
func ToMapWithRunner[T any, K comparable, V any](ch <-chan T, runner Runner, f func(T) (K, V)) map[K]V {
	map2entry := func(t T) mapEntry[K, V] {
		k, v := f(t)
		return mapEntry[K, V]{Key: k, Value: v}
	}

	map2kv := func(e mapEntry[K, V]) (K, V) { return e.Key, e.Value }

	return ToMapSuccessive(MapWithRunner(ch, runner, map2entry), map2kv)
}

// ToMapSuccessive returns a map containing all values read from ch.
// The map key-value pairs are determined by f
func ToMapSuccessive[T any, K comparable, V any](ch <-chan T, f func(T) (K, V)) map[K]V {
	m := map[K]V{}
	EachSuccessive(ch, func(value T) {
		k, v := f(value)
		m[k] = v
	})
	return m
}

// ToStructMap returns a struct{} map containing all values read from ch as keys.
// It is a shorthand for ToMap(ch, func(value T) (T, struct{}) { return value, struct{}{} })
func ToStructMap[T comparable](ch <-chan T) map[T]struct{} {
	return ToMap(ch, func(value T) (T, struct{}) { return value, struct{}{} })
}