example.jsonnet

// mapObjects applies func on every object in a tree.
local mapObjects(obj, func=function(n, o) {}) = {
  [n]+: mapObjects(obj[n], func) + func(n, obj[n])
  for n in std.objectFields(obj)
  if std.isObject(obj[n])
};

// deepMerge applies a patch to every object matching a predicate.
local deepMerge(obj, patch, pred=std.isObject) = obj + mapObjects(obj, function(n, o) if pred(o) then patch else {});

/// Example

local tree = {
  universe: {
    life: {
      kind: 'foo',

      everything: self.b * $.params.mult,
      b:: 0,
      x:: 1,

      rec: {
        kind: 'foo',
        x:: 22,
      },
    },
  },

  params:: {
    mult: 1,
  },
};

local patch = {
  b: 20 + self.x,
};

local parentPatch = {
  params+: { mult: 2 },
};

local isFoo(o) = std.objectHas(o, 'kind') && o.kind == 'foo';


// implement deepMerge 'manually' for this particular object tree:
local manual(obj, patch) = obj {
  universe+: {
    life+: patch {
      rec+: patch,
    },
  },
};

{
  manual: manual(tree, patch) + parentPatch,
  merge: deepMerge(tree, patch, isFoo) + parentPatch,
  std: tree + std.mapWithKey(function(n, o) if isFoo(o) then o + patch else o, tree) + parentPatch,

  eq: std.assertEqual(self.manual, self.merge),
  neq: if self.manual == self.std then error 'mapWithKey should be broken' else true,
}

output.json

{
   "eq": true,
   "manual": {
      "universe": {
         "life": {
            "everything": 42,
            "kind": "foo",
            "rec": {
               "b": 42,
               "kind": "foo"
            }
         }
      }
   },
   "merge": {
      "universe": {
         "life": {
            "everything": 42,
            "kind": "foo",
            "rec": {
               "b": 42,
               "kind": "foo"
            }
         }
      }
   },
   "neq": true,
   "std": {
      "universe": {
         "life": {
            "everything": 0,
            "kind": "foo",
            "rec": {
               "kind": "foo"
            }
         }
      }
   }
}