Is there a golang package that is equivalent to Python's ChainMap? - go

Question

Python's ChainMap enables you to chain together several maps such that a lookup searches all of the maps in sequence until a matching key is found. Here is one of many articles about it:
https://dzone.com/articles/python-201-what-is-a-chainmap
And the official documentation:
https://docs.python.org/3/library/collections.html
Does anyone know of any existing equivalent package written in Go? I've so far been unable to find one, and would like to avoid re-inventing the wheel if one does exist.

Answer 1

There's not package but it's fairly simple to implement something similar:
Let's do it with a map[string]interface{}
package main
import (
"reflect"
"testing"
)
type ChainMap struct {
Map map[string]interface{}
maps []map[string]interface{}
}
func NewChainMap(maps ...map[string]interface{}) ChainMap {
if len(maps) == 0 {
return ChainMap{
Map: make(map[string]interface{}, 0),
maps: maps,
}
}
r := make(map[string]interface{}, len(maps[0]))
for i := len(maps) - 1; i >= 0; i-- {
m := maps[i]
for k, v := range m {
r[k] = v
}
}
return ChainMap{
Map: r,
maps: maps,
}
}
func (c ChainMap) Parents() ChainMap {
if len(c.maps) < 2 {
return c
}
return NewChainMap(c.maps[1:]...)
}
A small test:
func TestChainMap(t *testing.T) {
var m = NewChainMap(
map[string]interface{}{
"foo": "bar",
},
map[string]interface{}{
"foo": "baz",
"hello": "world",
},
map[string]interface{}{
"foo": "baw",
},
)
if !reflect.DeepEqual(
m.Map,
map[string]interface{}{
"foo": "bar",
"hello": "world",
},
) {
t.Fail()
}
if !reflect.DeepEqual(
m.Parents().Map,
map[string]interface{}{
"foo": "baz",
"hello": "world",
},
) {
t.Fail()
}
}

Answer 2

I eventually found an implementation buried in the bigkevmcd/go-configparser package: https://github.com/bigkevmcd/go-configparser/blob/master/chainmap/chainmap.go
The upside of this one is that it uses the original maps for storage, so does the right thing if one of them is updated later; this makes it work more like the original python version. The downside is that the caller needs to call Get() and Len() functions rather than simply using the object as a normal map.
package chainmap
type Dict map[string]string
type ChainMap struct {
maps []Dict
}
func New(dicts ...Dict) *ChainMap {
chainMap := &ChainMap{
maps: make([]Dict, 0),
}
for _, dict := range dicts {
chainMap.maps = append(chainMap.maps, dict)
}
return chainMap
}
func (c *ChainMap) Len() int {
return len(c.maps)
}
func (c *ChainMap) Get(key string) string {
var value string
for _, dict := range c.maps {
if result, present := dict[key]; present {
value = result
}
}
return value
}