Struct context keys

June 17, 2025

First off, an apology for being rather unreliable with my “daily” emails. I’m in the middle of some traveling (was in the UK and Netherlands last week, and will be on a US road trip starting tomorrow), so I’m writing when I have a spare moment, which isn’t that often.


I’ve been talking about finding the ideal type for a context key. So far I’ve looked at empty structs (e.g. struct{}), integers, and strings. Today I’ll look at one other type, before discussing conclusions: non-empty structs.

type contextKey struct{ name string }

var (
	KeyUserID        = &contextKey{"user_id"}
	KeyTransactionID = &contextKey{"transaction_id"}
	KeyMessageID     = &contextKey{"message_id"}
)

This has been my default approach for years, based on having seen this used in the standard library.

But how does it stack up? Let’s see…

  1. Must be comparable.

✅ Check. Unlike pointers to empty structs, which may all point to the same memory location, teach key instance points to a distinct memory location, and is comparable.

  1. Use minimal memory.

✅ Yep. This approach I estimate would use 16-24 bytes per key instance, depending on architexture.

  1. Should be readable.

Yes!

fmt.Printf("failed to read context key %s", KeyMessageID)
// prints:  failed to read context key &{message_id}
  1. Easy to declare multiple keys per package.

✅ Super easy!

  1. Nice if it works with const

❌ NO!

Structs cannot be constants in Go.

Despite the lack of support for constants, this is still a strong candidate, and a pattern used frequently in the standard library.


Share this

Direct to your inbox, daily. I respect your privacy .

Unsure? Browse the archive .

Related Content


Context key type: Final recommendation

First, a correction! An astute reader pointed out that I made a small mistake in my post on June, 10, with regard to string context keys. My code example showed: type contextKey string const ( KeyUserID = "user_id" KeyTransactionID = "transaction_id" KeyMessageID = "message_id" ) But it should have been: type contextKey string const ( KeyUserID contextKey = "user_id" KeyTransactionID contextKey = "transaction_id" KeyMessageID contextKey = "message_id" ) This is a nasty kind of bug, because the code will continue to work as expected—just without any protection from key collisions!


String context keys

By now we’ve looked at empty structs (struct{}), and integers as possible context key types. Today, let’s consider string context keys. type contextKey string const ( KeyUserID contextKey = "user_id" KeyTransactionID contextKey = "transaction_id" KeyMessageID contextKey = "message_id" ) How does this stack up against our 5 criteria? Must be comparable. ✅ Check. Use minimal memory. ✅ Using a string will typically use a bit more memory than an integer (typically 32 bytes vs 16), but still quite minimal.


Integer context keys

We’re looking at different types for context keys. So far, we’ve looked at empty structs (struct{}), and found it to be less than ideal. Today, let’s consider integer context keys. This seems handy, right? type contextKey int const ( KeyUserID int = iota KeyTransactionID KeyMessageID . . . KeyFoo ) Let’s see how it stacks up to our 5 criteria: Must be comparable. ✅ No problem! Use minimal membory. ✅ int doesn’t have as small a memory footprint as struct{}’s zero bytes, but it’s still pretty small.

Get daily content like this in your inbox!

Subscribe