Object key literals

[no-more-secrets]

json j = {
  "hello"_key = 42,
  "world"_key = nullptr,
};

That would create an object with the given key/value pairs, which I think is nicer that the current syntax {{k,v},{k,v}}.

Should be simple to implement.

[gregmarr]

I don't see the _key syntax as any nicer than what's already there, it's definitely longer than the current syntax. I imagine getting that syntax working is going to be a bit of a pain. How would this require the = value part?

json j = {
  "hello"_key = 42,
  "world"_key = nullptr,
};

json j = {
  { "hello", 42 },
  { "world", nullptr},
};

[no-more-secrets]

If you think it's too long then you could shorten the literal suffix to _k.

Not sure if I understand your question about the "= value". If you are wondering about implementation, it is a simple matter of creating a new literal suffix that returns a proxy object (say, of type P) that can then be given an operator= that consumes and stores a value, returning another P. The final json object will then see that it is being initialized from a std::initializer_list<P>, from which it can extract the keys and values. The entire thing should fit in about 20-30 lines I imagine. If you want a full godbolt example I can write one, but hopefully what I've described above is sufficient.

[gregmarr]

If you think it's too long then you could shorten the literal suffix to _k.

I think that's even worse, as you had to have created this as a global user defined literal, and _k is too generic to be a global literal, or you have to have it namespaced and then you have to add a using declaration for it.

Not sure if I understand your question about the "= value".

I mean, what happens if the user doesn't add the = value part? Do you get a nice clean compiler failure? Do you get a result with null values?

json j = {
  "hello"_key,
  "world"_key,
};

Note that I'm not the maintainer, just a user, but I don't see any benefit to this additional syntax for constructing JSON objects. What is the benefit of adding "hello"_key = 42 as an additional way to say { "hello", 42 }? (This is an additional way, as you can't remove the existing way, probably not even in a major revision, as it would break far too much working code.)

[no-more-secrets]

I think that it is mostly subjective which syntax is preferable; I wouldn't suggest that my preference be imposed by replacing the current syntax. It is just an additional option for those who prefer it.

At the very top of the readme for this repo, it says the following:

Intuitive syntax. In languages such as Python, JSON feels like a first class data type. We used all the operator magic of modern C++ to achieve the same feeling in your code.

And that is what the proposed syntax does -- it uses operators to make the syntax resemble Python a bit more closely. In Python it would essentially be this:

j = {
  "hello": 42,
  "world": None
}

or

j = dict(
  hello=42,
  world=None
)

In C++ we can't do the former, but we can do the latter. I think that the proposed syntax more closely resembles both of the Python ways than the current syntax with additional braces. But as I mentioned, I am not proposing to replace the existing syntax, it's just an alternative for those who consider it subjectively better.

[no-more-secrets]

For this case:

json j = {
  "hello"_key,
  "world"_key,
};

We can make it give a clean compile error by having "hello"_key yield a type P and "hello"_key=42 yield type Q. The json constructor from std::initializer_list<Q> will exist, while the one that takes a std::initializer_list<P> will contain a static_assert giving the user a friendly error message that they forgot the =value.

[nlohmann]

I agree with @gregmarr . I don't think adding another syntax is the way to go.

[no-more-secrets]

Ok thx, will close then.