[stormbrew]

There's a few really awkward corner cases that are much clearer in YAML (and, it seems, LCON). The most significant one, to me, is lists of objects, which are perhaps not so common in code literals (hence why people don't tend to run into it in coffeescript), but do tend to come up a lot in structured documents. In JSON they are trivial:

    [
      {
        "a": "b",
        "c": "d"
      },
      {
        "e": "f",
        "g": "h"
      },
    ]

In YAML also trivial and very concise:

    - a: b
      c: d
    - e: f
      g: h

But in CSON (if I remember correctly), I think this looks odd and confusing by comparison:

    [
      a: "b"
      c: "d"
    , # <- note dedent, without this it comes out as one object not two
      e: "f"
      g: "h"
    ]

Now, in each of these you can just revert back to JSON for the difficult part, but that kind of defeats the purpose. I think YAML-the-syntax strikes a really nice balance between eliminating unnecessary punctuation and having solid structure, and LCON seems like it does as well. CSON errs too far on removing punctuation without a lot of thought put into the remaining structure.

If I understand correctly, the above example in LCON would be (at most minimal):

    . a b
      c d
    . e f
      g h

I actually really dislike this use of . and would like to know a rationale for it, to be honest.

[ar-nelson]

This was one of the reasons I designed it the way I did; I think it's a nice middle ground between YAML and CSON.

As for the ., I chose it over - or * for the bullet character because I designed LCON as the syntax for a JSON-Lisp programming language, and - or * could conceivably be used as prefix operators for math functions (* [5, 6]), leaving . as the only "bullet-like" ASCII character left.

The more I write LCON, the more I realize that the . can be difficult to see (though it's still not as bad as CSON's dedented commas...), so I can see your point, I'm just not sure what other character to use. In an earlier version, I had used :: as a bullet, but that ended up looking ugly.

[stormbrew]

If I was working in a language that used isomorphic json-like, I think I'd expect it to have call signatures more like smalltalk (object verb subject) than lisp (verb object), so calling '-' or '*' would seem strange to me.

But I don't know anything about this other project of yours other than what you've said here.

[spb]

I'd say just use hyphens like YAML, but I guess I get the keyspace-advantage of using a dot. Still an aggravating change.