URF: Elegant, Simple, Flexible Data Representation Framework
URF is a framework for storing data, independent of any serialization format.
URF can be considered a simpler RDF with more features and a pervasive elegance.
TURF: Intuitive, Flexible Serialization Format
TURF, the text-based serialization of URF, is reminiscent of JSON but with a staggering number of types, intuitive representations, and more human-readable line formatting. It handily functions as a less verbose but more capable replacement for XML, and with filler whitespace removed it nears the storage efficiency of binary.
The following are representations of common types in TURF, JSON, RDF, and XML:
| Type | TURF | JSON | RDF | XML |
| string |
"abc" |
"abc" |
"abc" or "abc"^^xsd:string |
"abc" or 'abc' |
| character |
'a' |
N/A |
N/A |
N/A |
| integer |
#123# |
123 |
"123"^^xsd:integer |
N/A |
| date time |
@1980-05-06T16:39:57-08:00@ |
N/A |
"1980-05-06T16:39:57-08:00"^^xsd:dateTime |
N/A |
| URI |
<http://www.example.com/> |
N/A |
"http://www.example.com/"^^xsd:anyURI |
N/A |
| Boolean |
_true_ |
true |
"true"^^xsd:boolean |
N/A |
| regular expression |
/a?b+c*/ |
N/A |
N/A |
N/A |
| URI-identified resource |
«http://example.com/resource»
|
N/A |
<http://example.com/resource> |
N/A |
Comparisons
Differences between URF and JSON
- Any URF resource may be identified by a URI. JSON makes no provision for identifying resources.
- URF allows globally consistent semantic properties by identifying resources with URIs. JSON properties names are local and may clash with semantically distinct property names among resources.
- URF provides a system for grouping resources within a common namespace, with the management of control for those namespaces facilitated by the Internet domain name system. JSON properties cannot be so aportioned, making name clashes more likely.
- URF has a set type,
«http://urf.name/urf/Set», and a map type, «http://urf.name/urf/Map». JSON has no set type.
- URF has three concrete number types,
«http://urf.name/urf/Rational», «http://urf.name/urf/Integer», and «http://urf.name/urf/Ordinal». JSON has only a single number type.
- URF has a character type,
«http://urf.name/urf/Character». JSON has no character type.
- URF has several date/time types which are compatible with [ISO 8601], [RFC 3339], and [RFC 2445]. JSON has no date or time type.
Differences between URF and RDF
URF is a semantic superset of RDF. Anything that can be represented by the RDF abstract syntax can be represented by the URF abstract model. Converting from URF to RDF is possible but would require special URF-related RDF ontologies to encapsulate the extra semantics built into the URF abstract model.
- URF considers all resources equal, providing for consistent identification and property designation of every resource. RDF considers certain resources, such as numbers and strings, to be of special literal resource types which are not identified by URIs (in contrast to all other non-literal resources) and to which properties cannot be given.
- URF provides a facility for declaring the order of properties. RDF has no such facility.
- URF provides for contextual properties. RDF has no such concept.
- URF has a character type,
«http://urf.name/urf/Character». RDF, which uses XML Schema datatypes [XML Schema 2], has no character type.
- URF has a regular expression type,
«http://urf.name/urf/RegularExpression». RDF has no regular expression type.
- URF has an enumerated type,
«http://urf.name/urf/Enum», as well as a facility for declaring enumerated values. RDF has no dedicated enumerated type. The RDF typed literal may be used to mimic enumerated types, but RDF provides no built-in facility for creating a new enumerated type or declaring its values.
- URF allows a knowledge community to be named and described. RDF does not provide such a "named graph" facility.
Differences between URF and XML
- URF provides a single type of subrelation: properties. XML provides two types of subrelations: attributes and child elements.
- URF uses global URIs to identify nodes in a graph. XML uses string IDs local to the defining document.
Differences between TURF and RDF/XML
- TURF allows any resource, including strings and other resources in inline namespaces, to be labeled for later reference. RDF/XML does not allow so-called RDF literal resources to be labeled.
- TURF allows any resource to appear in a list. RDF/XML does not allow so-called RDF literal resources to appear in a list.