new data format

[vitiral]

So I've been tossing an idea for a data format around in my head for a while now, and this seems like a good application so I thought I would throw it out.

Basically the data format is roughly this: xml in json-syntax. The idea is to have a json/yaml-like syntax but with attributes. So you could write something like this:

foo @{x: 42, y: 72, z}:
    a: "this is a key: string"

@dec_attr: "This is a decorating bar"
bar: "this is bar"

The basic idea is that attribute maps denoted by @ can be placed either after a key or above a key. After a key they must be in the form @{ ... } and above the key they must be in the form @key = value.

The basic idea is to make it easy to have keys with attributes associated with them -- such as types, generics, compiler flags, etc. This kind of language could be used for writing type systems, as a new programming langauge, or almost anything! If you think about it, programming languages are pretty much just variable names with some attributes (as well as some logic handlers... which would not be included in this spec).

Maybe significant white-space is not desired, or requiring "" around keys is desired. You could still use much the same syntax:

{
  "foo" @{"x": 42, "y": 72, "z": true}: {
    "a": "this is a key: string",
  },
  @"dec_attr": "This is decorating bar",  # <-- note the `,` is necessary
  "bar": "this is bar",
}

Also note that {z} is interpreted {z: true} to make passing flags easier. That could also be removed.

One advantage of this system is a clear distinction between the user's logic and the compiler or type-system's logic. The compiler is pretty much only concerned with the attributes (which the user uses to communicate with the compiler). So everything in an attribute is a compiler/language directive, and everything outside an attribute is a user-defined name/value/type.

Anyway, just something I've been tossing around in my head, thought you might like it for some food for thought!

[vitiral]

Also, I really like the idea of refusing to allow '' in general usage, instead using them for raw strings of the form '" where you can simply add as many ' as you need.

"foo": ''"This is a multi-line string containing "'. 
This is the next line.
"''

would be basically equivalent to the following in rust:

let foo = r##"This is a multi-line string containing "#. 
This is the next line.
"##;

[torkleyy]

This looks pretty complex. I'm not sure why one would want attributes, since it is always unclear to me what should be an attribute. But I could see some multi-line feature integrated in RON, probably the way Rust does it.

[vitiral]

attributes would be in the language/type specification. So they would be only things defined by the compiler (type, generics, etc).

The idea is that attributes encapsulate all the requirements that custom syntax normaly specifies. So instead of saying:

x: HashMap<String, Vec<u64>>

You would have

@where: {value: "u64"}
V: Vec

@where: {key: "String", value: "V"}
x: "HashMap"

and hashmap would be defined like:

@where: {H: ["Hashable"]}
HashMap: {
   key: "H",
   value: "Generic",
}

Something like that... again, this isn't completely flushed out, I just thought you might like it as food for thought :)

[vitiral]

the goal is to make the parsing step ultra-simple as well as reduce the amount of syntax that someone has to learn. People would just have to learn the attributes and how attributes work together... and that's it. Everything else would be "just data"

[torkleyy]

Closing alternative issues and listing them in the wiki page.