Implement errgroup from Scratch | DevPrep

Implement errgroup from Scratch | DevPrep

package errgroup

import (
    "context"
    "sync"
)

type Group struct {
    cancel  context.CancelFunc
    wg      sync.WaitGroup
    errOnce sync.Once
    err     error
}

func WithContext(ctx context.Context) (*Group, context.Context) {
    ctx, cancel := context.WithCancel(ctx)
    return &Group{cancel: cancel}, ctx
}

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()
                }
            })
        }
    }()
}

func (g *Group) Wait() error {
    g.wg.Wait()
    if g.cancel != nil {
        g.cancel()
    }
    return g.err
}

package main

import (
    "context"
    "fmt"
    "net/http"
)

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    
    urls := []string{
        "https://api.service-a.com/data",
        "https://api.service-b.com/data",
        "https://api.service-c.com/data",
    }
    
    results := make([]string, len(urls))
    
    for i, url := range urls {
        i, url := i, url // Capture loop variables
        g.Go(func() error {
            req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
            resp, err := http.DefaultClient.Do(req)
            if err != nil {
                return err
            }
            defer resp.Body.Close()
            // Process response...
            results[i] = "success"
            return nil
        })
    }
    
    if err := g.Wait(); err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println("All requests succeeded")
}