\n<\/p>\n
That is legitimate JSON:<\/p>\n
That is invalid JSON:<\/p>\n
The distinction is the final comma. The JSON grammar specifies {that a} comma can separate two members of an object however not postcede (“path”) a member. I believe this was a design mistake. Say we wish to add two new keys to the struct, one earlier than the “a” member and one after the “c” member. This is what it will seem like if trailing commas had been permitted:<\/p>\n
It is the very same textual content transformation no matter the place we add the important thing. Within the present mannequin, we as a substitute have this:<\/p>\n
These are totally different transformations! Equally if you wish to take away a component, you’ll be able to’t simply delete the corresponding line, you must delete the road after which verify that the final line would not have a trailing comma. Do not even get me began on all of the particular instances concerned in swapping two strains.<\/p>\n
JSON is not the one language with this downside. Haskell writes file varieties like this:<\/p>\n
This “partial bullet level” model of placing separators in the beginning of rows makes it simpler to alter the final row however tougher to alter the primary one. <\/p>\n
TLA+ has this downside too:<\/p>\n
This one’s annoying as a result of 1) you are always including new top-level variables whereas engaged on a spec and a pair of) the PlusCal DSL doesn’t have this downside:<\/p>\n
The worst offenders, IMO, are logic languages like Prolog. Not solely do not you might have trailing separators, you might have a particular terminating image:<\/p>\n
I assume you’ll be able to type of consider it as funny-lookin’ braces:<\/p>\n
However this isn’t normal syntax and folks will take a look at you bizarre in the event you attempt it. And you continue to do not get trailing separators.<\/p>\n
Some languages permit trailing separators:<\/p>\n
However I believe we will do one higher than that. Python and Go commas can path however not lead, which means we won’t go 100% bullet factors:<\/p>\n
Now I personally assume that bullet factors are the bee’s knees and want extra languages allowed main separators. TLA+ truly has main conjunction and disjunction operations:<\/p>\n
|| && a == 3
\n && b == 4\n<\/p><\/div>\n
You may’t path these, although, no writing (a &&).<\/p>\n
Essentially the most versatile I’ve seen is Alloy, which permits each main and trailing commas:<\/p>\n
sig<\/span> <\/span>AlsoValid<\/span> <\/span>{<\/span> Alloy does go slightly power-mad right here, as a result of it additionally permits empty separators.<\/p>\n
\n <\/span>a<\/span>:<\/span> <\/span>1<\/span>,<\/span>
\n <\/span>b<\/span>:<\/span> <\/span>2<\/span>,<\/span>
\n}<\/span>\n<\/div>\n
\n <\/span>