Ability to exclude field from a struct

[btrepp]

So I have the below, which does work.

package tasks

_input: spec:template:spec:containers:[_]
_container_name: string

_clean:containers: {
    for c in _input.spec.template.spec.containers  {
        if c.name != _container_name {
            c
        }
        if c.name == _container_name {
            for k,v in c if k!="image"{
                "\(k)":v
            }
        }
    }
}

_clean:template_spec: { 
    for k,v in _input.spec.template.spec if k!= "containers" {
        "\(k)" : v
    }   
    containers: _clean.containers
}

_clean:template: {
    for k,v in _input.spec.template if k!= "spec" {
        "\(k)": v
    }
    spec: _clean.template_spec
}

_clean:spec: {
    for k,v in _input.spec if k!= "template" {
        "\(k)": v
    }
    template: _clean.template
}

_clean:manifest: {
    for k,v in _input if k != "spec" {
        "\(k)": v
    }
    spec: _clean.spec
}

My aim here is to take a Kubernetes yaml, and remove the specific 'image' tag, so that I can override it later, as my understanding is cue combines all files, so if it is already defined I have to remove it.
Current idea for workload is, load yaml at _input, created a filtered one, combine that with the path of the value I want it to be, export resulting file as new yaml.

As such I don't know all the keys/fields, and want to copy unknowns as is.

The above does give me the filtered version, but it's pretty verbose. In other languages you are sometimes able to duplicate structs with a 'with' syntax, thus allowing targeted changes. Ideally does something like

a: { c: 1}
b: { a with c:2}

exist?. Would be amazing if it allowed structs of depth too such that

a: b: c:d: 1
a: b1: c1: d2:2

new: { a with a.b1.c1.d2:3}

would allow surgical changes.

Unsure if this is supported by the language, but it would be great for validated patches/changes of yaml/json

[infogulch]

Something like the JavaScript merge function (edit: I mean Object.assign()) would work for this case. I don't see anything like that in the stdlib (maybe it ought to be), but I suspect it should be possible to write a general implementation of that in pure cue, maybe with the function pattern.