code: func NewWorker(nWorkers int, fn func(el interface{}, ok bool)) chan<- interface{} {
  	if nWorkers == 0 {
  		panic("NewChanWorker: invalid value of 0 for nWorkers")
  	}
  	retc := make(chan interface{}, buffered)
  	if nWorkers < 0 {
  		// Unbounded number of workers.
  		go func() {
  			var wg sync.WaitGroup
  			for w := range retc {
  				wg.Add(1)
  				go func(w interface{}) {
  					fn(w, true)
  					wg.Done()
  				}(w)
  			}
  			wg.Wait()
  			fn(nil, false)
  		}()
  		return retc
  	}
  	w := &chanWorker{
  		c:     retc,
  		workc: make(chan interface{}, buffered),
  		donec: make(chan bool), // when workers finish
  		fn:    fn,
  		buf:   list.New(),
  	}
  	go w.pump()
  	for i := 0; i < nWorkers; i++ {
  		go w.work()
  	}
  	go func() {
  		for i := 0; i < nWorkers; i++ {
  			<-w.donec
  		}
  		fn(nil, false) // final sentinel
  	}()
  	return retc
  }
docs: // NewWorker starts nWorkers goroutines running fn on incoming
  // items sent on the returned channel.  fn may block; writes to the
  // channel will buffer.
  // If nWorkers is negative, a new goroutine running fn is called for each
  // item sent on the returned channel.
  // When the returned channel is closed, fn is called with (nil, false)
  // after all other calls to fn have completed.
  // If nWorkers is zero, NewWorker will panic.