Wait of function result after context cancellation

Question

I can't understand the logic of this example in Go Concurrency Patterns: Context

func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {
    // Run the HTTP request in a goroutine and pass the response to f.
    c := make(chan error, 1)
    req = req.WithContext(ctx)
    go func() { c <- f(http.DefaultClient.Do(req)) }()
    select {
    case <-ctx.Done():
        <-c // Wait for f to return.
        return ctx.Err()
    case err := <-c:
        return err
    }
}

Before that it is said that:

The Done method returns a channel that acts as a cancellation signal to functions running on behalf of the Context: when the channel is closed, the functions should abandon their work and return.

It looks like the equivalent of awaiting of <-c only, without case <-ctx.Done() at all. So, what is the point?

Answer 1

The context may cancel the Do call. The case <-ctx.Done() unambiguously identify that this happened.

Indeed, we may assume that the Do call would then return a nil http.Response, and that the function f would then return an error when this happens. But we wouldn’t know why f received a nil http.Response as input argument.

The instruction case err := <-c: handles the case when the error is produced inside f.