Templates and defaults

[slewiskelly]

For the purposes of this example consider the following definition:

#A: {foo: {[string]: string}}

This is common in third-party definitions which have mapping, for example Kubernetes metadata.labels.

Now consider a situation where I would want to to create a definition based on this one, providing some defaults.

I would first be inclined to write it like:

#A: {foo: {[string]: string}}

#B: #A & {
	foo: _ | *{
		"a": "1"
		"b": "2"
	}
}

b: #B & {
	foo: "c": "3"
}

However this adds "c": "3" to the set, rather than replaces it:

{
    "b": {
        "foo": {
            "c": "3",
            "a": "1",
            "b": "2"
        }
    }
}

The same goes for the following:

#A: {foo: {[string]: string}}

#B: #A & {
	foo: {[string]: string} | *{
		"a": "1"
		"b": "2"
	}
}

b: #B & {
	foo: "c": "3"
}

{
    "b": {
        "foo": {
            "c": "3",
            "a": "1",
            "b": "2"
        }
    }
}

However, the following works as I would want/expect:

#A: {foo: {[string]: string}}

#B: #A & {
	foo: [string]: string | *{
		"a": "1"
		"b": "2"
	}
}

b: #B & {
	foo: "c": "3"
}

{
    "b": {
        "foo": {
            "c": "3"
        }
    }
}

This feels like a bug, but I'm uncertain. If it isn't I think it should be documented somewhere.

[verdverm]

I think the last example is structured as follows, with the parentheses. It does not seem possible to get the default value to be used.

#A: {foo: {[string]: string}}

#B: #A & {
	foo: [string]: (string | *{
		"a": "1"
		"b": "2"
	})
}

b: #B & {}

[slewiskelly]

Ah yeah, you're right. I thought I had this working right somehow, but maybe not.

I basically just want to know how, or even if it should be possible, to have defaults when using templates.

[verdverm]

Your answer was and is close :]

What was happening is that the extra field did not prevent the a&b from being included in the result. Open structs in disjunctions are often a source of confusion or indecision (on CUE's part). By closing the disjunction element, it only applies on an exact match, or in this case when nothing is presented.

#A: foo: [string]: string

#B: #A & {
    foo: _ | *close({
	"a": "1"
	"b": "2"
    })
}

b: #B & {
	foo: "c": "3"
} 

[slewiskelly]

Makes perfect sense, thanks!