difference between kdl and others

[soloturn]

https://kdl.dev mentions a couple of other config languages in comparison to kdl, which is very helpful. somebody of you has similar insight for:

• lua
• ron, https://github.com/ron-rs/ron
• dhall https://dhall-lang.org/

[tryoxiss]

* lua

Lua is a lightweight scripting language, making it suitable for configs where you may repeat yourself a lot, often in applications which are heavy enough to justify including a scripting language as part of it. It is also, like most formats, strictly Key-Value where kdl is node based, this is also true for the other formats you mention.

* ron, https://github.com/ron-rs/ron

RON is a format designed for and that works well with Rust and the way it stores and handles data. It supports structures for data, proper sum types, and optional values. It is sort of like a "JSON++", despite not being a superset of it. It is suited for config formats, data serialization (more so in local applications like games, configs, rather than over the net like JSON)

* dhall https://dhall-lang.org/

I don't know much about DHall, but I believe it has small scripting capabilities like Lua. From a quick look, it appears to be sort of like Nix.

[tabatkins]

Yeah, lua is just straight up a programming language, and dhall is a "programmable config language", so basically a simple programming language. Both are far outside the scope of what KDL is trying to do.

RON is comparable, but its goals are to be close to Rust syntax, and it pays for that in a decent degree of complexity - there are several different types of nodes, each with their own syntax. In general KDL can encode the same things much more simply, for example:

// RON example from their homepage:
Scene( // class name is optional
    materials: { // this is a map
        "metal": (
            reflectivity: 1.0,
        ),
        "plastic": (
            reflectivity: 0.5,
        ),
    },
    entities: [ // this is an array
        (
            name: "hero",
            material: "metal",
        ),
        (
            name: "monster",
            material: "plastic",
        ),
    ],
)

vs the same in KDL

Scene {
    materials {
        metal reflectivity=1.0
        plastic reflectivity=0.5
    }
    entities {
        - name=hero material=metal
        - name=monster material=plastic
    }
}

tho to be fair, the RON example partially looks worse just due to the excess whitespace and comments. Stripping it down equivalently:

Scene(
    materials: {
        "metal": (reflectivity: 1.0, ),
        "plastic": (reflectivity: 0.5, ),
    },
    entities: [
        (name: "hero", material: "metal", ),
        (name: "monster", material: "plastic", ),
    ],
)

It doesn't look quite as bad, but there's still several distinct syntaxes on display for largely the same things. In Rust those syntaxes are well-justified, but for general purpose data it's a bit much.

[xpe]

@tabatkins Thanks for this. After searching around the document, this one place is the only place where I've seen documentation for the KDL's use of - for arrays. Did I miss something?

[bgotink]

@xpe That's how arrays are set up in JSON-in-KDL. KDL itself doesn't have the concept of an array (or object), since it's node based rather than value based like JSON or YAML.

[xpe]

Thanks for pointing that out. (To state what might be obvious: since JSON-in-KDL is a subset of KDL, the example works in both.)

[zkat]

The - isn't just a JSON-in-KDL thing. It's a convention for when you want a bunch of array-ish things, especially when you need additional metadata for them.

For smaller array of a few items where all items are simple values, it's recommended you use multiple arguments instead. cf.

foo 1 2 3 4
bar {
  - a x=1
  - b x=2
  - c x=3
  - d
  - e
  - f
  - g
  - h
}