Golang Concurrency：sync.errgroup

package main
import (
  "context"
  "fmt"
  "golang.org/x/sync/errgroup"
  "os"
)
var (
  Blogger   = find("1227368500")
  Weibo = find("H3GIgngon")
)
type Result string
type Find func(ctx context.Context, query string) (Result, error)
func find(kind string) Find {
  return func(_ context.Context, query string) (Result, error) {
    return Result(fmt.Sprintf("%s result for %q", kind, query)), nil
  }
}
func main() {
  SinaWeibo := func(ctx context.Context, query string) ([]Result, error) {
    g, ctx := errgroup.WithContext(ctx)
    finds := []Find{Blogger, Weibo}
    results := make([]Result, len(finds))
    for i, find := range finds {
      i, find := i, find // https://golang.org/doc/faq#closures_and_goroutines
      g.Go(func() error {
        result, err := find(ctx, query)
        if err == nil {
          results[i] = result
        }
        return err
      })
    }
    if err := g.Wait(); err != nil {
      return nil, err
    }
    return results, nil
  }
  results, err := SinaWeibo(context.Background(), "https://weibo.com/1227368500/H3GIgngon")
  if err != nil {
    fmt.Fprintln(os.Stderr, err)
    return
  }
  for _, result := range results {
    fmt.Println(result)
  }
}

// Package errgroup provides synchronization, error propagation, and Context
// cancelation for groups of goroutines working on subtasks of a common task.
package errgroup
import (
  "context"
  "sync"
)
// A Group is a collection of goroutines working on subtasks that are part of
// the same overall task.
//
// A zero Group is valid and does not cancel on error.
type Group struct {
  cancel func()
  wg sync.WaitGroup
  errOnce sync.Once
  err     error
}
// WithContext returns a new Group and an associated Context derived from ctx.
//
// The derived Context is canceled the first time a function passed to Go
// returns a non-nil error or the first time Wait returns, whichever occurs
// first.
func WithContext(ctx context.Context) (*Group, context.Context) {
  ctx, cancel := context.WithCancel(ctx)
  return &Group{cancel: cancel}, ctx
}
// Wait blocks until all function calls from the Go method have returned, then
// returns the first non-nil error (if any) from them.
func (g *Group) Wait() error {
  g.wg.Wait()
  if g.cancel != nil {
    g.cancel()
  }
  return g.err
}
// Go calls the given function in a new goroutine.
//
// The first call to return a non-nil error cancels the group; its error will be
// returned by Wait.
func (g *Group) Go(f func() error) {
  g.wg.Add(1)
  go func() {
    defer g.wg.Done()
    if err := f(); err != nil {
      g.errOnce.Do(func() {
        g.err = err
        if g.cancel != nil {
          g.cancel()
        }
      })
    }
  }()
}