JSON++

JSON++ is a powerful data representation language that comes in the form of a strict superset of the popular JSON data language. It supports useful structures such as trees, graphs, and ordered dicts.
== Syntax ==
JSON++ supports new types of data structure and possibly data type that JSON does not natively support, instead requiring that the user build them themselves. These structures and types, both old and new, are:
Data 	Meaning 	Representation 	
Integer (augmented from JSON)	A whole number from -∞ to ∞ (in theory) 	Can be represented in multiple ways: No prefix means decimal, the 0b prefix means binary, the 0q prefix means quaternary, 0o octal, 0x hexadecimal, and 0rn roman numerals. Written using just the digits in that range (hex uses A-F or a-f and roman numerals use {I, V, X, L, C, D, M} or the lowercase equivalent, but you can't mix). Meaningless Underscores available for readability.	
Real (from JSON) 	A real number 	Written as the number with a decimal point. If the decimal is 0, can be treated as an integer. 	
String (augmented from JSON) 	A list of characters that form a word, sentence, paragraph, or really anything. 	Written as the characters padded in quotes (single or double, but must be consistent), with special characters backslash-escaped (the only ones this is really necessary for are quotes, but you can do pretty much any of them). Single words that don't mean anything special are converted to strings. (e.g. walrus == "walrus" && + == "+") 	
Bool (from JSON) 	A 1 or 0, True or False, etc. etc. etc. 	Either "True", "False", "T", or "F" 	
Null (from JSON) 	A non-value; the value that represents no data. 1 possible state. 	Just "null" 	
List (from JSON) 	An ordered, nestable collection of 	The values, separated by commas, padded in [ and ]. Empty list represented as "[]" 	
Chord (new, syntactic sugar) 	A string (converted to a list of integers upon creation) 	A quoted string prefixed by "c", equivalent to a list of the character ordinals. 	
Tuple (new) 	A non-growable list (more for the languages reading) 	Written as a parenthesis-surrounded comma-separated list. Empty written as "(,)", single-item as "(<val>,)". 	
Set (new) 	A non-ordered collection of items 	A comma-separated list padded in "{" and "}". 	
Dict (from JSON) 	An unordered map of items to values 	A comma-separated list of key:value pairs padded in {...}. Empty written as {:}. 	
OrderedDict (new) 	An ordered map of items to values 	A comma separated list of key:value pairs padded in [...]. Empty written as [:]. 	
SymmetricDict (new) 	A map with the property that if x↦y, then y↦x. 	Written like a normal dict, but key-value pairs are written x<=>y. 	
OrderedSymmetricDict (new) 	An ordered map with the same property as a SymmetricDict 	Written like an OrderedDict, but key-value pairs are written x<=>y. 	
Lispt (new) 	A lisp-like list; a special object that tells the computer to perform an operation on	Padded in "(" and ")", no commas. Empty lispt "()". 	
Edge (new, niche) 	A connection between pieces of data, used for graphs 	Written value -- value 	
DiEdge (new, niche) 	A directed edge connecting two pieces of data in one direction. 	Written origin -> destination 	
Graph 	An undirected graph: a number of "vertices" connected by "edges" 	...|}-padded list of edges and scalar values, representing connections and nodes, respectively. 	
DiGraph 	A directed graph: vertices connected by edges monodirectionally 	...|}-padded list of diedges and scalar values, representing connections and nodes, respectively. 	
Matrix 	A matrix of values (similar to a singly-nested list, but its own efficient data type)	...|], with non-comma-separated values inside. Rows are separated by 	symbols (and all must be the same length, of course). All data types must be the same.
Note that a JSON++ file that does not have brackets at the toplevel will default to being a scalar, a list, an ordered dict, or a symmetric ordered dict, depending on the inner formatting.
== Equivalence to JSON ==
Though this may change, it JSON is currently equivalent to JSON++. The correspondences are as such (note that the "Pure" JSON versions probably should be written as a length-2 list with the first argument being the type as a string):
;JSON++ integers:
 10 // decimal
 0b10 // binary
 0q10 // quaternary
 0o10 // octal
 0x10 // hexadecimal
 0xII // Roman Numerals
;Pure JSON integers:
 10 // decimal
 2 // binary
 4 // quaternary
 8 // octal
 16 // hexadecimal
 2 // Roman Numerals
;JSON++ String:
 abc
 "narwhals"
 "I am\nthe walrus"
 "Hello,
 World!"
;Pure JSON String:
 "abc"
 "narwhals"
 "I am\nthe walrus"
 "Hello,\nWorld!"
;JSON++ Tuple:
 (5, 16)
;Pure JSON Tuple:
 [5, 16]
;JSON++ Chord:
 c"Hello, World!"
;Pure JSON Chord:
 [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
;JSON++ Set:
 {1, 2, 3}
;JSON Set:
 [1, 2, 3]
;JSON++ Ordered Dict: 
 [
 3: "c",
 2: "b",
 1: "a"
 ]
;Pure JSON Ordered Dict:
 {
 "order": [3, 2, 1],
 "dict": [
 3: "c",
 2: "b",
 1: "a"
 ]
 }
;JSON++ Symmetric Dict:
 {
 "a" <=> 1,
 "b" <=> 2,
 "c" <=> 3,
 }
;Pure JSON Symmetric Dict:
 [["a", 1], ["b", 2], ["c", 3]]
;JSON++ Ordered Symmetric Dict:
 [
 "a" <=> 1,
 "b" <=> 2,
 "c" <=> 3,
 ]
;Pure JSON Ordered Symmetric Dict:
 [["a", 1], ["b", 2], ["c", 3]]
;JSON++ Lispt:
 (+ 1 2 3)
;Pure JSON Lispt:
 ["+", 1, 2, 3]
or:
 {
 "command": "+",
 "args": [1, 2, 3]
 }
;JSON++ Edge:
 a -- b
;Pure JSON Edge:
 ["a", "b"]
;JSON++ DiEdge:
 a -> b
;Pure JSON DiEdge:
 ["a", "b"]
;JSON++ Graph:
 {| a, b, c, a -- b, b -- c, c -- a |}
;Pure JSON Graph:
 [["a", "b", "c"], [["a", "b"], ["b", "c"], ["c", "a"]]
;JSON++ DiGraph:
 {| a, b, c, d, a -> b, b -> c, c -> a, c -> d |}
;Pure JSON DiGraph:
 [["a", "b", "c", "d"], [["a", "b"], ["b", "c"], ["c", "a"], ["c", "d"]]
or:
 {
 "a": ["b"],
 "b": ["c"],
 "c": ["a", "d"],
 "d": []
 }
;JSON++ Matrix:
 [| 1 2 3 || 4 5 6 || 7 8 9 |]
;Pure JSON Matrix:
 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Category:Languages