8. Tags
Readable Object Notation

Tag names are strings, including spellings such as true, null, or 42. Names are separated by whitespace, even when the group spans lines. Commas do not separate tags. The closing > ends the group rather than becoming part of a bare name. Use ordinary key quoting for names containing whitespace or delimiters, or beginning with a literal !. The negation marker goes outside the quoted name:

<"display name" !"not active" "!literal">

<"!literal" "display name" !"not active">

{
  "display name": true,
  "not active": false,
  "!literal": true
}

The literal ! in "!literal" is part of the key and participates in sorting. The negation marker before "not active" does not.

An empty key can be written "", or !"" for a false value. A negation marker without a name is invalid.

A tag group is recognized only where an object member can begin. An ordinary object key beginning with < must be quoted. Inside a bare string, after its first character, < and > are ordinary text, as in a<b.

A tag group may also stand alone in value position: in a list, as a member value, or as a tagged element's payload. There it is a whole map whose members are its tags, so <a !b> reads as {a true b false}. The formatter writes every nonempty map whose members are all booleans this way, without braces. A map with any other member keeps its braces, and the empty map stays {}.

list [{<b a>} {x true y false} {}]
member {active true}
nested {outer {inner {<on>}}}
prefixed #err {<integer overflow>}
mixed {<a> n 1}

list [<a b>
      <x !y>
      {}]
member <active>
mixed {<a>
       n 1}
nested {outer {inner <on>}}
prefixed #err <integer overflow>

{
  "list": [
    {
      "b": true,
      "a": true
    },
    {
      "x": true,
      "y": false
    },
    {}
  ],
  "member": {
    "active": true
  },
  "nested": {
    "outer": {
      "inner": {
        "on": true
      }
    }
  },
  "prefixed": {
    "#err": {
      "integer": true,
      "overflow": true
    }
  },
  "mixed": {
    "a": true,
    "n": 1
  }
}

list [<b a> <!c>]
member <active>
prefixed #err <overflow integer>
nested [[<a>] {k <b>}]

list [<a b> <!c>]
member <active>
nested [[<a>]
        {k <b>}]
prefixed #err <integer overflow>

{
  "list": [
    {
      "b": true,
      "a": true
    },
    {
      "c": false
    }
  ],
  "member": {
    "active": true
  },
  "prefixed": {
    "#err": {
      "overflow": true,
      "integer": true
    }
  },
  "nested": [
    [
      {
        "a": true
      }
    ],
    {
      "k": {
        "b": true
      }
    }
  ]
}

A string that begins with < is therefore quoted:

quoted ["<foo" "<" "<=" a<b]

quoted ["<foo" "<" "<=" a<b]

{
  "quoted": [
    "<foo",
    "<",
    "<=",
    "a<b"
  ]
}

A tag-only map ends on the line where it opens. An empty group <> is invalid, since {} already writes the empty map.

Tags work in every object, including nested objects and objects containing only boolean members:

person {
  <active !admin>
  name Ada
}
flags {<readable !writable>}

flags <readable !writable>
person {<active !admin>
        name Ada}

{
  "person": {
    "active": true,
    "admin": false,
    "name": "Ada"
  },
  "flags": {
    "readable": true,
    "writable": false
  }
}

A tags-only document such as <active> represents an implicit outer object, just as ordinary members do. It is already in canonical form. An empty group <> contributes no members and is omitted by the formatter. An object with no members formats as {}.

For example, this input:

<>
name Ada

name Ada

{
  "name": "Ada"
}

<>

{}

{}

Tag groups may span lines and contain comments using the ordinary comment rules. Comments are stored in the enclosing object's $comment member, using the key name without the negation marker. Formatting preserves whether a comment appears before a tag or inline after it, and keeps it with that key when tags are sorted. When the first tag has no leading comment, canonical output places it immediately after <; later tags and their comments align beneath it. If a comment must precede the first tag, < stays on a line of its own. A closing > follows the final tag unless a trailing comment requires it on the next line.

For example, this input:

<
  !admin ; Access restrictions
  active
>

<active
 !admin ; Access restrictions
>

{
  "$comment": "admin: Access restrictions",
  "admin": false,
  "active": true
}

If an earlier tag has a trailing comment and the final tag does not, the closing > follows the final tag:

<
  !admin
  active ; Enabled by default
>

<active ; Enabled by default
 !admin>

{
  "$comment": "active: Enabled by default",
  "admin": false,
  "active": true
}

A comment on a separate line immediately before !admin instead uses admin:: Access restrictions.

<
  ; Enabled by default
  active
  !admin
>

<
  ; Enabled by default
  active
  !admin>

{
  "$comment": "active:: Enabled by default",
  "active": true,
  "admin": false
}