Possible approaches to mapping XML into CUE Values

[lorrrrrrrenzo]

Summarizing and continuing public and private conversations concerning the addition of encoding/xml to CUE and the need to arrive at an acceptable XML->CUE mapping.

Approach 1

My naive approach to this placed attributes of an XML node into an attrs array, with each child node added to a children list. With this approach I was able to translate XML to CUE and back, albeit with some deviations that seem straightforward to address. The issue here is that the resulting CUE seems 'unergonomic' and out of line with how other CUE I've seen is structured. One example of this is how CUE paths turn into an inscrutable chain of repetitive array access clauses (e.g., encoded.children[2].children.[1].children[0].attrs.identifier). This strikes me as undesirable, especially when thinking about this CUE would need to interact with other CUE and writing abstract definitions to constrain XML formats.

Example XML

<alice xmlns="http://some-namespace" xmlns:charlie="http://some-other-namespace">
    <bob>david</bob>
    <charlie:edgar>frank</charlie:edgar>
</alice>

Example CUE

A: {
	name: "alice"
	attrs: {
		xmlns:   "http://some-namespace"
		charlie: "http://some-other-namespace"
	}
	children: [{
		name: "bob"
		text: "david"
	}, {
		name: "edgar"
		text: "frank"
	}]
}

Approach 2

Matthew turned me on to BadgerFish (homepage, Google Cloud documentation), which is one accepted approach of translating XML into JSON. One benefit is that the CUE paths are far more sensible (e.g., A.alice.bob.$) and the resulting CUE is more compact and much easier to write constraints against. I have not deeply checked if the XML can be stably* recreated from this encoding, but my sense from looking at it is that it should not be a problem.

(NB: By "stable recreation" here I pointedly exclude the goal of recreating the original XML input, instead preferring the goal of stability of regeneration once the XML document has been marshalled into CUE. In other projects I've seen requests for libraries to support the exact recreation of the original XML document after a round-trip, but that seems to add a lot of difficulty without much benefit.)

Example XML (same as above)

<alice xmlns="http://some-namespace" xmlns:charlie="http://some-other-namespace">
    <bob>david</bob>
    <charlie:edgar>frank</charlie:edgar>
</alice>

Example CUE

A: {
    "alice": {
        "bob": {
            "$": "david",
            "_xmlns": {
                "charlie": "http://some-other-namespace",
                "$": "http://some-namespace"
            }
        },
        "charlie:edgar": {
            "$": "frank",
            "_xmlns": {
                "charlie": "http://some-other-namespace",
                "$": "http://some-namespace"
            }
        },
        "_xmlns": {
            "charlie": "http://some-other-namespace",
            "$": "http://some-namespace"
        }
    }
}

I'm not convinced that this is a final answer, but I think it's a useful starting point for a technical discussion.

Outstanding Questions

• I keep hearing that XML namespaces are particularly gnarly when designing en/decoders for XML, but I have not come to understand the exact reason why yet. This is probably worth a discussion.
• How closely do we want to track XPath syntax for queries?
• The priority of supporting attributes and namespaces. My take is the serious users of XML are in large enterprises, where these features are routinely used.