I've been reading around on this and I'd like a sanity check on the solution I'm thinking about before I bake it into a public API.
The problem: I'm providing a 2 way mapping from Go to another type system (https://godoc.org/qpid.apache.org/amqp for the curious). The specific problem: AMQP allows maps with mixed type key/value (no problem there - map[interface{}]interface{}) but some maps have "restricted type" rules, such as "the key may only be of AMQP type ulong or symbol" - in Go that means uint64 or 'type Symbol string' since AMQP symbol and string are encoded differently. So how to represent this in a way that is: - efficient - Go-like: use type switch/type assertion as normal - type safe: I could just use map[interface{}] but then illegal key types wouldn't be caught till runtime Here's my solution - I have seen the tag technique used e.g. in the go parser, but I haven't seen it in a public API, so wonder if there are any gotchas or better ideas. Overall I'm pretty happy with it, the need for an extra type and conversions for uint64 isn't ideal but it's not too bad. Code below is a simple executable, obvoiusly the real think will be in package amqp (or maybe package amqp.restrict, there are other type restrictions to deal with and I'd like to keep dummy types like Uin64 out of the general population...) package main // Public interface type Symbol string type Uint64 uint64 // An AnnotationKey can be either a Uint64 or a Symbol. // // NOTE: Uint64 is equivalent to the built-in type uint64, but is distinct so // the compiler can detect illegal types being used with AnnotationKey // See the example for more type AnnotationKey interface { allowedAsAnnotationKey() // A marker method so the compiler can restrict to legal types, does nothing. } func (Uint64) allowedAsAnnotationKey() {} func (Symbol) allowedAsAnnotationKey() {} func main() { var k AnnotationKey k = AnnotationKey(Symbol("foo")) var s Symbol s = k.(Symbol) println(s) // Note conversions needed between built-in uint64 and Uint64 var n uint64 // Built-in uint64 type n = 42 k = AnnotationKey(Uint64(n)) // Convert to Uint64 to use with AnnotationKey n = uint64(k.(Uint64)) // Convert back to built-in uint64 println(n) /* // The following will not compile without explicit conversion: k = AnnotationKey(n) // Cannot convert: use k = AnnotationKey(Uint64(n)) n = k.(Uint64) // Cannot assign: use n = uint64(k.(uint64) // The following types are not allowed for AnnotationKey k = AnnotationKey("foo") // Cannot convert: string is not allowed for AnnotationKey k = AnnotationKey(true) // Cannot convert: bool is not allowed for AnnotationKey */ } -- You received this message because you are subscribed to the Google Groups "golang-nuts" group. To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
