Map key merging is different from internal x/config library. about config HOT 4 CLOSED

The internal merge is based on applying yaml unmarshaler repeatedly on the same variable, which doesn't have any documented merge behavior and is not recursive for interface{}, but is for structs. Here is an example:

package main

import (
	"fmt"

	yaml "gopkg.in/yaml.v2"
)

const (
	base = `
test:
  testmap:
    testkey: test
`
	dev = `
test:
  testmap:
    testkey2: anothervalue
`
)

func main() {
	type Config struct {
		Test map[string]interface{} `yaml:"test"`
	}
	type StructConfig struct {
		Test struct {
			Testmap struct {
				Testkey  string
				Testkey2 string
			}
		}
	}

	var c Config
	var s StructConfig
	for _, str := range []string{base, dev} {
		if err := yaml.Unmarshal([]byte(str), &c); err != nil {
			panic(err)
		}
		if err := yaml.Unmarshal([]byte(str), &s); err != nil {
			panic(err)
		}
	}
	fmt.Printf("interface config:\n %+v\n", c)
	fmt.Printf("struct config:\n %+v\n", s)
}

Output:

interface config:
 {Test:map[testmap:map[testkey2:anothervalue]]}
struct config:
 {Test:{Testmap:{Testkey:test Testkey2:anothervalue}}}

Config library is being consistent in that case and behaves in a similar way as json merge patch by merging everything recursively.

from config.

I was under the impression that the internal configuration library was always
performing a deep merge--that seems like the correct behavior to have if we're
going to have merging at all.

@alsamylkin, putting aside whether we should do this or not, is it even
technically feasible to replicate the behavior?

from config.

@abhinav Unfortunately it doesn't do a deep merge and I don't see we can replicate this behavior: merge and decoding are separate steps in config library, but the internal merge depends on the type of variable being decoded. I am happy to jam offline on a solution though.

from config.

Synced offline and decided to not to try mimic the internal merge and keep it as is.

from config.