Son

I opened an issue for this here: https://github.com/seagreen/Son/issues/10 I'm curious about how often enough trailing zeros occur in real world documents for lack of exponential notation to have a noticeable impact on document size.

There's a github issue on this, titled "Son inherits the weakness of JSON by not specifying the numeric value ranges" [1], in case anyone has anything concrete to suggest. [1] https://github.com/seagreen/Son/issues/3

I definitely meant ordering by Unicode code points. Someone very helpfully opened an issue and we're trying to figure out the right wording there: https://github.com/seagreen/Son/issues/13

Have you seen my Son project? (https://github.com/seagreen/Son) I think I may have gotten JSON canonicalization right. Also, I'm collecting a list of all subsets of JSON here if anyone knows of more: https://housejeffries.com/page/7 EDIT: Wow there's a lot of criticism in this thread. For the record I think TJSON is great.

There's an issue for min and max number values here: https://github.com/seagreen/Son/issues/3 Son seems like a natural place to put restrictions on them, but I'm not sure if there's way to do it that (A) still makes for a clean spec and (B) still allows everything floats can encode to to be used.

The plan is to go codepoint by codepoint in ascending order: `{"Z":3,"a":0,"\u0073\u0323\u0307":1,"\u1E69":2}` See this issue for the discussion: https://github.com/seagreen/Son/issues/1 My current understanding is that RFC 7159 doesn't require Unicode normalization to be performed, if it does we're in trouble: https://tools.ietf.org/html/rfc7159

Good catch. I kind of slacked on this since I knew it would be a solvable problem once everything else got worked out. Right now the reference implementation sorts by comparing codepoints one-on-by one. When it reaches a codepoint that's unequal or nonexistant it orders the string with the lesser or nonexistant codepoint first. So in your example, after serializing from JSON and deserializing to Son we get `{"op":0,"öp":1}`. Two remaining questions: 1. What's the most unambiguous way to describe this process? 2. Right now the comparison is on unescaped strings. Should it be on escaped strings instead? There's an issue open to discuss this here: https://github.com/seagreen/Son/issues/1 EDIT: I am curious what Unicode recommends for language-aware sorting, even though we're not going to use it. Is this the right place to look? http://unicod

jq is great. You can actually see how it's used to test the reference implementation of Son here (https://github.com/seagreen/Son/blob/master/implementation/t...) using `jq --compact-output --sort-keys .` Unfortunately, jq doesn't provide flags to control scientific/non-scientific notation or which characters are escaped, meaning if you want very tight control over the JSON generated it's not a full option. (Consider that the motivating example in the Son README isn't all you might want to use Son for. For instance some people need consistent hashing of serialized JSON documents).

Thanks for brining Canonical JSON up. There's an issue to investigate it here: https://github.com/seagreen/Son/issues/7 It doesn't appear that Canonical JSON does anything about redundant escape sequences in JSON. I'm still looking into it to be sure. This is a big part of the motivation behind the Son spec, and represents about half the EBNF: https://github.com/seagreen/Son/blob/master/son.ebnf#L19 For anyone else who knows of more JSON subsets, if you report them here: https://housejeffries.com/page/7 it would be really appreciated. I definitely don't want to do duplicate work.

Why not use Markdown instead of MediaWiki syntax? About URLs, you can take a look at StrongLink: https://github.com/btrask/stronglink Your JSON subset is very interesting too: https://github.com/seagreen/Son