An example for struct deep merging (with key path deletable).

[morlay]

import (
	"list"
)

// avoid structure cycle
_recurseN: {
	#iter: {
		#next: _
		#func: _
	}

	#maxiter: *20 | uint

	for k, v in list.Range(0, #maxiter, 1) {
		#iters: "\(k)": (#iter & {#next: #iters["\(k+1)"]}).#func
	}

	#iters: "\(#maxiter)": null

	#iters["0"]
}

_has: {
	#o: _
	#k: _

	if #o[#k] != _|_ {true}
	if #o[#k] == _|_ {false}
}

_isObject: {
	#o: _

	if (#o & {...}) != _|_ {true}
	if (#o & {...}) == _|_ {false}
}

#mergeF: {
	#next: _
	#func: {
		#oa: _
		#ob: _

		for ka, va in #oa if !(_has & {_, #o: #ob, #k: ka}) {
			"\(ka)": va
		}

		for ka, va in #oa if (_has & {_, #o: #ob, #k: ka}) {
			let vb = #ob[ka]

			// remove when vb is "-"
			if ((vb & "-") == _|_) {
				// switch case like
				"\(ka)": [
						if (_isObject & {_, #o: va}) && (_isObject & {_, #o: vb}) {(#next & {_, #oa: va, #ob: vb})},
						vb,
				][0]
			}
		}

		// clone prop not in #a
		for kb, vb in #ob if !(_has & {_, #o: #oa, #k: kb}) {
			"\(kb)": vb
		}

		// empty fallback for json
		{}
	}
}

_merge: _recurseN & {#iter: #mergeF}

_origin: {
	a: {
		a: {
			a: "a.a.a"
			b: "a.a.b"
			c: "a.a.c"
		}
		b: "a.b"
		c: "a.c"
	}
	b: "b"
}

{
	(_merge & {_, #oa: _origin, #ob: {
		a: a: a: "a.a.a+"
		c: c: "c.c+"
		// just a special value for remove
		a: a: c: "-"
	}})
}
// Output:
// a:
//   a:
//     a: a.a.a+
//     b: a.a.b
//   b: a.b
//   c: a.c
// b: b
// c:
//   c: c.c+

A question:
Could it be simpler ?

[verdverm]

It could be simpler for the evaluator if you avoid the _has and _isObject. I would separate merge (upsert) from remove (mask) and apply them one after another rather than trying to mix them. I would also avoid using special data or substrings to indicate that a value should be operated on for these types of helpers and instead rely on unification. You could then even remove based on constraints like a regex or numerical comparison.

• https://github.com/hofstadter-io/cuetils/blob/main/structural/upsert.cue
• https://github.com/hofstadter-io/cuetils/blob/main/structural/mask.cue

package structural

import (
	"github.com/hofstadter-io/cuetils/recurse"
)

#upsertF: {
	#next: _
	#func: {
		#X: _
		#U: _
		upsert: {
			for i,x in #X {
				let u = #U[i]
				// if in upsert, we're going to replace
				if u != _|_ {
					// if orig is a struct, recurse
					if (x & {...}) != _|_ {
						"\(i)": (#next & { #X: x, #U: u }).upsert
					}
					// otherwise set to u
					if (x & {...}) == _|_ {
						"\(i)": u
					}
				}
				// if not in upsert, copy orig x
				if u == _|_ {
					"\(i)": x
				}
			}

			// now look for anything in U that is not in X
			{
				for i,u in #U {
					if #X[i] == _|_ {
						"\(i)": u
					}
				}
			}
		}
	}
}

#Upsert: recurse.#RecurseN & { #funcFactory: #upsertF }

[morlay]

Is any simple way for recurse ?

[verdverm]

With an evaluator change which would allow bounded recursion, which has been discussed in #990

Then recursion would be allowed up to a limit and implemented directly in the evaluator, which in theory does not break the Turing incompleteness