Rust

Something like Python largely turns to word soup in my brain.

Really? I feel the opposite. I'd much rather have indentation enforced by the language than merely convention.

That said, I prefer braces, mostly because it makes things like inline functions more reasonable (the lambda syntax sucks IMO), and my editor does a great job matching on braces.

JSON has a mismatch for use in configuration. The keys in a object don’t need to be quoted.

The stupidest thing IMO is that JSON came from JavaScript, but it loses the flexibility of JavaScript. The quotes thing is acceptable IMO since it allows for flexibility in keys (e.g. you can have a URL as a key), but these aren't:

• comments - why don't just let implementations not propagate them?
• trailing commas - should be optional or required, not forbidden
• NaN and Infinity - valid floating point numbers, so why are they forbidden?

I don’t particularly care for having each line terminated with a semi-colon

I love that semicolons mean something in Rust. Since pretty much everything is an expression, you only need a semicolon to turn it into a statement. That's really nice!

I don't think it has anything to do with error messages though, plenty of languages do that well without it.

Are you talking about rust or toml? Because if rust, just out of curiosity, would you still like it with keywords instead of symbols?

Config should be pretty flat.

Why? I don't see any reason for that.

TOML rocks precisely because it nudges you into making simpler configs.

This is just "you're holding it wrong".

In most cases you don’t, and when you do, it’s possible and not unreasonable.

Really. Here's the first Gitlab CI example I could find:

lintDebug:
  interruptible: true
  stage: build
  script:
    - ./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint
  artifacts:
    paths:
      - app/lint/reports/lint-results-debug.html
    expose_as: "lint-report"
    when: always

Let's see the TOML:

[lintDebug]
interruptible = true
stage = "build"
script = [
  "./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint"
]

  [lintDebug.artifacts]
  paths = [ "app/lint/reports/lint-results-debug.html" ]
  expose_as = "lint-report"
  when = "always"

Gross. The tool I used to convert even added extra indentation because otherwise it is unclear.

IMO JSON5 is the best:

{
  lintDebug: {
    interruptible: true,
    stage: 'build',
    script: [
      './gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint',
    ],
    artifacts: {
      paths: [
        'app/lint/reports/lint-results-debug.html',
      ],
      expose_as: 'lint-report',
      when: 'always',
    },
  },
}

This is much clearer than TOML and less ambiguous than YAML. It could do without the outer {}, but overall it's still better.

Right but JSONC does support them. We just want support for JSONC as well as JSON.