masking records

[majidaldo]

would there be a way to create a 'mask' for records (antimerging?)? i guess it would need a recursive filter.

{ f0.f01 = "something", f1=42}  (maskOp)  {f0.f01 = null }   =gives=> {f1=42}

this doesn't work

std.record.remove "bar.bar" { foo = "foo", bar.bar = "bar" }

[vkleen]

If you just want to remove a field at some deeply nested location, you can write that using std.record.remove and std.record.update:

let rec remove_path = fun path r =>
  let length = std.array.length path in
  let head = std.array.first path in
    if length == 0 then r
    else if length == 1 then std.record.remove head r
    else if std.record.has_field head r then
      std.record.update head (remove_path (std.array.drop_first path) r."%{head}") r
    else r
in remove_path ["bar", "bar"] { foo = 1, bar.bar = 2 }

It doesn't remove a field if it would end up being an empty record, but that shouldn't be hard to add. Maybe utilities like that could be good candidates for a future standard library expansion.

[yannham]

And if you want to remove a bunch of fields, you can convert the record to an array using std.record.to_array, filter out everything you don't want via std.array.filter (using a similar logic as in @vkleen's answer), and then reconstruct the record with a final std.record.from_array.

As an aside, because fields can be missing a definition in Nickel ("partial configurations"), you can even have an interface like (note the first argument, the mask, where you don't have to set = null):
[EDIT: sorry, this part is wrong. Although you can write the mask {f0.f1, foo, bar}, trying to call a record function such as std.record.has_field on it will fail because of some contract and type intricacies. We might want to have a variant of those functions that work, because you should be able to get the list of fields even if some are undefined, but that's unfortunately not the case currently]

my_mask_function {f0.f1, foo, bar} { f0.f01 = "something", f1=42, foo = "1", bar = "2"}  =gives=> {f1=42}

Another operator we considered at some point is the converse, the projection operator:

project {f0.f1, foo, bar} { f0.f01 = "something", f1=42, foo = "1", bar = "2"}  =gives=> {f0.f1 = "something", foo = "1", bar = "2"}

If that's useful to people, we could add it to the sdtlib!

Note: when using record.from_array and record.to_array, the final record obtained will lose some information about recursive values, or inter-dependencies:

nickel> let interdep = {foo = bar + 1, bar = 0} in interdep & {bar | force = 3}
==> { foo = 4, bar = 3 }

nickel> let interdep = {foo = bar  + 1, bar = 0}
  |> std.record.to_array
  |> std.record.from_array
in
interdep & {bar | force = 3}
==> { foo = 1, bar = 3 }

Once transformed to an array, all fields are evaluated to a final, standard value. This might also happen with @vkleen's remove-based suggestion for subrecords, because of the record.update (though top-level values should stay the same). Just something to keep in mind, that it's best to not rely anymore on recursive overriding after such an operation.

[yannham]

Note: I edited some part, because the suggestion didn't work all the way through.

[majidaldo]

ya perhaps something like this should be elevated to syntax? i feel like it's just the inverse of the merge op.

thanks!