Hi @eccles,

The context.Context mechanism's primary mission is to allow cross-cutting concerns to travel across API boundaries without the entire application needing to agree on what those cross-cutting concerns are.

For example, in my own application I might have decided to use a particular distributed tracing instrumentation API, but it's unlikely that third-party libraries I'm using will have made the same decision. If I'm using a function in that third-party library to indirectly call a function in my own application -- a typical example being stdlib net/http.Server/Client calling my own application's http.Handler or httptrace.ClientTrace -- I cannot modify net/http's API to specify that it should expect and pass downstream a context.Values specifically.

With that said, I feel unsure about how the more specific interfaces you described here would be used. You say "API authors can then specify the correct context", but you've not described how the API author would decide which type to use.

If you are imagining using this only for calls between functions in a single codebase then indeed for that case I could imagine how that might work, but that situation is not the scenario that the context package API is intended for.

Of course that doesn't mean that the scope of context couldn't grow to better support that situation, but if that is your intention then I'd suggest including some concrete examples of how you'd use this in real code so that the value proposition is easier to see.

CC @Sajmani

Thank you @apparentlymart for your comments.

I am no proposing that we get rid of the generic context.Context. Just simply making it clearer for any particular API on how that AP is expected to be used with regards to the required context.Context argument.

So for example calling a listener of some kind (httpserver or similar):

  func (s *service) Listen(ctx context.Cancel, handle Handler)

which indicates that this function could be cancelled

or

   func (c *Client) Send(ctx context.ValuesDeadline, msg []byte)

which indicates that a timeout should be specified in the context and the Values will be used (maybe in the headers...)

or

    func (c *Client) Send( ctx context.Deadline, msg []byte)

which indicates that only a deadline will be expected in the context.