How do you iterate over an ordered map while preserving order? Implementation of the iteration method.

In Go, the standard map does not guarantee iteration order. To iterate over a map while preserving order, you need to use an additional structure, such as a slice of keys that maintains the insertion order.

Example implementation of an ordered map with an iteration method:

package orderedmap

type OrderedMap struct {
    keys []string
    data map[string]interface{}
}

func NewOrderedMap() *OrderedMap {
    return &OrderedMap{
        keys: make([]string, 0),
        data: make(map[string]interface{}),
    }
}

func (om *OrderedMap) Set(key string, value interface{}) {
    if _, exists := om.data[key]; !exists {
        om.keys = append(om.keys, key)
    }
    om.data[key] = value
}

func (om *OrderedMap) Get(key string) (interface{}, bool) {
    val, ok := om.data[key]
    return val, ok
}

func (om *OrderedMap) Iterate(f func(key string, value interface{})) {
    for _, key := range om.keys {
        f(key, om.data[key])
    }
}

Usage:

om := NewOrderedMap()
om.Set("first", 1)
om.Set("second", 2)
om.Iterate(func(k string, v interface{}) {
    fmt.Println(k, v)
})

Thus, the order of keys is preserved in the slice, and during iteration, we go through the keys in the desired order.