channel/of.go

package channel

import (
	"context"
	"iter"
	"time"
)

// Of returns a channel containing all values
func Of[T any](values ...T) <-chan T {
	return OfDelayed(0, values...)
}

// OfDelayed behaves like Of but with a pre-defined delay between each value
func OfDelayed[T any](delay time.Duration, values ...T) <-chan T {
	return OfDelayedFunc(func(value T) time.Duration { return delay }, values...)
}

// OfDelayedFunc behaves like OfDelayed but accepts a function to determine the delay
func OfDelayedFunc[T any](delayFunc func(value T) time.Duration, values ...T) <-chan T {
	out := make(chan T, len(values))

	go func(out chan T, values []T) {
		defer close(out)
		for i, value := range values {
			out <- value
			if i < len(values)-1 {
				time.Sleep(delayFunc(value))
			}
		}
	}(out, values)

	return out
}

// OfFunc returns a channel containing the return values of successively calling f
// It closes the channel as soon as ctx is done
func OfFunc[T any](ctx context.Context, buffer int, f func() T) <-chan T {
	out := make(chan T, buffer)

	go func() {
		defer close(out)

		for ctx.Err() == nil {
			select {
			case out <- f():
			case <-ctx.Done():
				return
			}
		}
	}()

	return out
}

// OfMap returns a channel containing the return values of the unmapper function
// applied to any key-value pair in m
// The order is random
func OfMap[K comparable, V, T any](m map[K]V, unmapper func(K, V) T) <-chan T {
	out := make(chan T, len(m))

	go func() {
		defer close(out)
		for k, v := range m {
			out <- unmapper(k, v)
		}
	}()

	return out
}

// OfSeq returns a channel containing all values provided by the iterator
func OfSeq[T any](seq iter.Seq[T], buffer int) <-chan T {
	out := make(chan T, buffer)

	go func() {
		defer close(out)
		for v := range seq {
			out <- v
		}
	}()

	return out
}

// OfSeq2 returns a channel containing the return values of the unmapper function
// when provided with the values of the iterator
func OfSeq2[K comparable, V, T any](seq iter.Seq2[K, V], buffer int, unmapper func(K, V) T) <-chan T {
	out := make(chan T, buffer)

	go func() {
		defer close(out)
		for key, value := range seq {
			out <- unmapper(key, value)
		}
	}()

	return out
}