I sympathize with your distaste. Languages and datatype could have been predicates of the named tuple or object, which would have given languages more flexibility in different domains, including more properties on the languages themselves.

On the other hand, the language tag drastically reduces ambiguity and processing cost in a collaborative multi-lingual dictionary. But that’s a datastore implementation detail, not something that should be encoded in the abstract or serialization formats.

JSON Triple Sets flattens the triple (octuple?) with s, p, o, s_type, p_type, o_type, o_datatype, o_lang. This could be implemented with a consistent hierarchy:

{s_value, s_type,
p_value, p_type,
o_value, o_type, o_datatype, o_lang}

or

{ s_value,
s_type,
p : [{ p_value,
p_type,
o : [{ o_value,
o_type,
o_datatype,
o_lang,
}]
}]
}

This implementation is coded in Javascript as a jQuery plugin that works with the rdfquery library. It converts data between JRON object structures and rdfquery databank objects.

Currently, part of the Shuffl project (http://code.google.com/p/shuffl/).

As for the use-case – you may be right, but if trying to round-trip between JSON and “real” RDF, then some way of handling multiple statements is needed (currently, my code dies if asked to serialize statements with multiple subjects to JRON). So maybe it doesn’t matter if its less pretty, as long as it’s possible.

Rather than using __values here, maybe use something like __statements? Not sure if that helps or hinders.

{ “__values”: [
{ 'foaf.name': 'Sandro Hawke',
'__node_id': 'n334' },
{ 'foaf.name': 'Eric Prud’hommeaux',
'__node_id': 'n102' } ],
“__prefixes”: {
“foaf.” : “http://xmlns.com/foaf/0.1/”
}

I can’t quite decide if that’s too confusing. I’m also not sure how common this case is; I think the typical JSON user is used to always having a JSON expression be one object, so they wouldn’t think to want this. For them sending one object or one array is fine (and more can be nested if necessary.)

How to represent this:

<?xml version=”1.0″?>
<rdf:RDF
xmlns:rdf=”http://www.w3.org/1999/02/22-rdf-syntax-ns#”
xmlns:foaf=”http://xmlns.com/foaf/0.1/”
>
<rdf:Description rdf:nodeID=”n334″>
<foaf:name>Sandro Hawke</foaf:name>
</rdf:Description>
<rdf:Description rdf:nodeID=”n102″>
<foaf:name>Eric Prud’hommeaux</foaf:name>
</rdf:Description>
</rdf:RDF>

On first reading, I assumed it would be an object, corresponding to a single RDF subject. But that doesn’t allow multiple statements about different subjects, such as would typically appear within an element.

A logical alternative would be an javascript array, which would need to be treated differently to property arrays which you have described – but I don’t see that’s particularly problematic.

Reducing it to a test case, how to represent this?:

Sandro Hawke

Eric Prud’hommeaux