Is there an easy way to iterate over a map in order?

Question

This is a variant of the venerable question "why is my cartographic question out of order".

I have a (rather large) number of mappings of the form map[MyKey]MyValue , where MyKey and MyValue are (usually) structures. I have less functions for all types of keys.

I need to sort the cards in order. (In particular, the order determined by the smaller function of this type.) At the moment, my code is as follows:

 type PairKeyValue struct { MyKey MyValue } type PairKeyValueSlice []Pair func (ps PairKeyValueSlice) Len() int { return len(ps) } func (ps PairKeyValueSlice) Swap(i,j int) { ps[i], ps[j] = ps[j], ps[i] } func (ps PairKeyValueSlice) Less(i,j int) { return LessKey(ps[i].MyKey, ps[j].MyKey) } func NewPairKeyValueSlice(m map[MyKey]MyValue) (ps PairKeyValueSlice) { ps = make(PairKeyValueSlice, len(m)) i := 0 for k,v := range m { ps[i] = PairKeyValue{k,v} i++ } sort.Sort(ps) } 

And then, anytime I need iteration in order, it looks like this:

 var m map[MyKey]MyValue m = GetMapFromSomewhereUseful() for _, kv := range NewPairKeyValueSlice(m) { key := kv.MyKey value := kv.MyValue DoUsefulWork(key, value) } 

And that seems to work basically. The problem is that it is terribly verbose. In particular, since the problem is actually very little related to the implementation of ordered maps, it really is useful work in a loop.

In addition, I have several different types of keys and values. Thus, every time I want to iterate over the map in order, I copy / paste all this code and find / replace MyKey new key and MyValue with a new value. Copy / paste this value ... "smelly." This has already become a hassle, as I have already made several mistakes that I had to correct several times.

This technique also has the disadvantage that it requires a complete copy of all keys and values. This is undesirable, but I do not see the way around it. (I could only reduce it to keys, but that does not change the underlying nature of the problem.)

This question is trying to do the same with strings. This question does this with strings and ints. This question implies that you need to use reflection and must have a switch statement that includes all possible types, including all user types.

But with people who are puzzled that maps do not determine iteration, it seems like this should be the best solution to this problem. I am from an OO background, so I probably missed something fundamental.

So, is there a reasonable way to iterate over the map in order?

---

Update: Editing the question to have more source information if there is a better solution than this.

I have a lot of things that I need to group for output. Each level of grouping is in a structure that looks like this:

 type ObjTypeTree struct { Children map[Type]*ObjKindTree TotalCount uint } type ObjKindTree struct { Children map[Kind]*ObjAreaTree TotalCount uint } type ObjAreaTree struct { Children map[Area]*ObjAreaTree TotalCount uint Objs []*Obj } 

Then I will ObjTypeTree over the children in ObjTypeTree to print Type groupings. For each of them, I ObjKindTree over ObjKindTree to print Kind groups. Iterations are performed using methods for types, and each type of type requires a slightly different way to print the grouping level. Groups must be printed in order, which causes a problem.

Answer 1

Do not use a card if key mapping is required. Use a B-tree or any other / similar ordered container.

Answer 2

The second answer is jnml. But if you need something less than yours, and you are ready to give up security such as compilation time, then my library may work for you. (It is built on top of reflect .) Here is a complete working example:

 package main import ( "fmt" "github.com/BurntSushi/ty/fun" ) type OrderedKey struct { L1 rune L2 rune } func (k1 OrderedKey) Less(k2 OrderedKey) bool { return k1.L1 < k2.L1 || (k1.L1 == k2.L1 && k1.L2 < k2.L2) } func main() { m := map[OrderedKey]string{ OrderedKey{'b', 'a'}: "second", OrderedKey{'x', 'y'}: "fourth", OrderedKey{'x', 'x'}: "third", OrderedKey{'a', 'b'}: "first", OrderedKey{'x', 'z'}: "fifth", } for k, v := range m { fmt.Printf("(%c, %c): %s\n", k.L1, k.L2, v) } fmt.Println("-----------------------------") keys := fun.QuickSort(OrderedKey.Less, fun.Keys(m)).([]OrderedKey) for _, k := range keys { v := m[k] fmt.Printf("(%c, %c): %s\n", k.L1, k.L2, v) } } 

Please note that this method will be slower, so if you need performance, this is not a good choice.