consider using orDone channel pattern

[plastikfan]

found on youtube learn the Go concurrency pattern that blew my mind (by Kantan Coding) (Not sure if this is applicable to anything in lorax, I just wanted somewhere to record the act that I saw this useful concurrency design pattern)

Allows the done/select channel pattern to be extracted out into another function that handles done notification using a separate go routine and a relay stream. Clients now do not need to implement the select/done channel, they instead range over the relay stream that is returned from the newly defined function orDone.

Here is the example code:

func main() {
	var wg sync.WaitGroup

	cows := make(chan interface{}, 10)
	done := make(chan interface{}, 10)

	wg.Add(1)
	go consumeCows(&wg, done, cows)
}

func consumeCows(wg *sync.WaitGroup, done, cows <-chan interface{}) {
	defer wg.Done()

	for cow := range orDone(done, cows) {
		fmt.Printf("%v\n", cow)
	}
}

func orDone(done, c <-chan interface{}) <-chan interface{} {
	relayCh := make(chan interface{})

	go func() {
		defer close(relayCh)

		for {
			select {
			case <-done:
				return
			case v, ok := <-c:
				if !ok {
					return
				}
				select {
				case relayCh <- v:
				case <-done:
					return
				}
			}
		}
	}()

	return relayCh
}

Also see: Go Concurrency Patterns: Pipelines and cancellation by Sameer Ajmani (13-mar-2014)