How to exclude some keys from an object?

[springcomp]

This is just a thought experiment, but how to exclude some keys from an object?
Maybe a convoluted expression using the existing keys(), values() and the upcoming items() and from_items() functions could do the trick. But Maybe we need a simpler syntax for that use case.

We may need to introduce a ... spread operator, and maybe a _ discard identifier.

Consider the sample from the JMESPath front page.

{
  "locations": [
    {"name": "Seattle", "state": "WA"},
    {"name": "New York", "state": "NY"},
    {"name": "Bellevue", "state": "WA"},
    {"name": "Olympia", "state": "WA"}
  ]
}

Let’s return all location objects, without the name property, for instance:

locations[].{_: name, without_name: ...@}

In the preceding expression the multi-select-hash looks like a destructuring syntax where

• _: name discards the name property and
• ...@ uses a hypothetical spread operator that takes all remaining (non-discarded) properties.

This would evaluate to:

[
    { "without_name": "WA" },
    { "without_name": "NY" },
    { "without_name": "WA" },
    { "without_name": "WA" },
]

[innovate-invent]

I think if we add set subtraction and the reduce projection it would be something like:
locations[].let({a: @}, &(keys(@) - ["name"])[&].(acc + {cur: a[cur]}))

[jdevillard]

This would evaluate to:

[
    { "without_name": "WA" },
    { "without_name": "NY" },
    { "without_name": "WA" },
    { "without_name": "WA" },
]

I think the result would be

[
    {"without_name": {state:"WA}},
    {"without_name": {state:"NY}},
    {"without_name": {state:"WA}},
    {"without_name": {state:"WA}}
}

because the spread operator that takes all remaining (non-discarded) properties and not only values.

I thought about some elements on this and examples during the day. I'll write it in this discussion asap

[springcomp]

True. So the desired result would be achieved using an more complex expression:

locations[].{_: name, without_name: ...@}[*].without_name

[springcomp]

Well, the more I think of it, the less I like my proposal.
merge() might be kludgey, but it remains the closest way IMHO, short of using a function.

locations[*].merge(@, {name: `null`, state: state, new: `"new"`})

So maybe we only need a way to discard values?

[jdevillard]

About what we thought together, the idea for me is to find a good function syntax to :

• discard some value
• copy some value
• modify some value

if possible using only 1 function.

I understand that we could certainly find a way to do this with some mix and match of function already present in the grammar but how to find the right compromise between :

• (re) implement in the library
  • could be use with a existing complex syntax
  • create a specific function will allow to not loop multiple time on the Json/Context/etc and give better perfs.
• readability for the user

[innovate-invent]

I think I have a solid solution here: #25 (reply in thread)

[jdevillard]

So If I resume the need , consider the following two JSONs :

Input:

{
    "a": "foo", 
    "b": "bar", 
    "c": "baz",
    "d": "boo",
}

Expected:

{
    "b": "bar", 
    "c": "new_baz"
}

The operations on the input are :

• remove a, d
• keep b
• modify c

Remove a and d could be done using :

@ - [a, d] refering to #25

Modify c AND keep b could be done using
merge(@, {c: "new_baz"})

and so the complete jmespath expression will be :

merge(@, {c: `"new_baz"`}) - [a, d]

It's not so difficult to create this kind of expression 😃 .
Don't now if we need other function (or composite function) for better readability but I think this kind of sample has it place in the FUP.

[innovate-invent]

I'd say functions/syntax should only do a single operation, readability can be done using whitespace.
If we start introducing high level functions, the spec will become overburdened very quickly.

[springcomp]

This recent issue also touches on this subject.

[springcomp]

JMESPath Community 1.1 now supports this scenario indirectly.