JSON encode supports encoding keyword lists to objects

[madlep]

Allow keyword lists with atom keys to be encoding with JSON module

Current:

Interactive Elixir (1.18.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> JSON.encode!([a: "foo", b: "bar"])
** (Protocol.UndefinedError) protocol JSON.Encoder not implemented for type Tuple, the protocol must be explicitly implemented.
...

With change:

Interactive Elixir (1.19.0-dev) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> JSON.encode!([a: "foo", b: "bar"])
"{\"a\":\"foo\",\"b\":\"bar\"}"

[madlep]

One edge case that could be done either way is encoding an invalid keyword list list such as [k1: "a", k2: "b", "BAD"], which isn't valid syntax in that form, but could still be expressed as [{:k1, "a", {:k2, "b"}, "BAD"], or duplicate keys like [k1: "a", k2: "b", k1: "c"].

This is using encode_key_value_list_checked/2, which will correctly raise an error on bad input: if there is a dup key, or any element that doesn't match {Key, Value} in the list, but will have a performance overhead.

Alternative is to just use encode_key_value_list/2, which is faster, but will allow duplicate keys to be encoded, and will just skip invalid list items.

[josevalim]

We must not change the elixir_json.erl file, as that was backported from Erlang, and the goal is to fully remove it. However note that Jason does not support keyword lists, nor does :json by default. So we need at least a discussion and some arguments on why this feature should be added.

cc @michalmuskala

[josevalim]

In any case, thank you for the PR!

[michalmuskala]

I would be against such a change since, as you said, it's just a heuristic and the list of pairs, might not actually be pairs after all - this can end up with quite confusing errors.
At the same time, why only pairs with atom keys? In the rest of the module we support any key that implements String.Chars protocol, so this seems quite inconsistent.
As a last point, if you really want to do it, json was designed to make it trivial. In particular, in your application you can easily define a wrapper that will provide it:

def encode!(value) do
  JSON.encode!(value, fn
    [{_, _} | _] = kv, encode -> :json.encode_key_value_list(kv, encode);
    other, encode -> JSON.protocol_encode(other, encode)
  end)
end

[sabiwara]

I would be against such a change since, as you said, it's just a heuristic and the list of pairs

Indeed, and there's also the issue of the empty list possibly meaning an empty object, but being translated as a list.

Perhaps a nice way to achieve this without ambiguity in user land could be to define a custom %JSONKeyValue{keyword: kw} struct implementing the JSON.Encode protocol?

[michalmuskala]

Perhaps a nice way to achieve this without ambiguity in user land could be to define a custom %JSONKeyValue{keyword: kw} struct implementing the JSON.Encode protocol?

That's what we had in Jason with Jason.OrderedObject

[josevalim]

Ok, given the feedback above, we won't move forward with this. Thanks! :)